OpenClaw mit ChatGPT Plus und Claude MAX: Von 400 € variablen API-Kosten zu planbaren Flatrates

Eine technische Schritt-für-Schritt-Anleitung für Docker-Umgebungen, am Beispiel einer Synology NAS – reproduzierbar nachgebaut, mit Backup-Gurt, Kostenbremse und ein paar Stolperdrähten, die man besser vorher sieht.

OpenClaw als selbst gehosteter KI-Agent im Container ist eine saubere Sache – bis die erste Monatsrechnung kommt. Wer seinen Agenten intensiv nutzt, erlebt schnell, wie Pay-per-Token-APIs im Hintergrund leise, aber sehr entschlossen weiterticken: Heartbeats, Memory-Updates, Recherchen, Folgeaufrufe. Das läppert sich. 150–400 €/Monat sind bei agentischem Dauerbetrieb kein Ausreißer, sondern Normalzustand.

Es gibt zwei Hebel, um das zu ändern:

Hebel 1 – Umstieg auf Flatrates: Statt Pay-per-Token übernehmen günstigere Abonnements die Alltagslast. ChatGPT Plus (~20 €/Monat) fährt die Kurzstrecke, Claude MAX kommt nur dann aus der Garage, wenn wirklich Drehmoment gebraucht wird.

Hebel 2 – Token sparen: Egal welcher Provider läuft – wer den Agenten beibringt, weniger Kontext zu schleppen, spart direkt. Kurze Regeldateien, strukturiertes Memory, kein automatisches Nachladen alter Logs: Das sind keine optionalen Extras, sondern der zweite Boden unter den Flatrate-Einsparungen.

Diese Anleitung zeigt beide Hebel zusammen, konkret und nachgebaut in einer Docker-Umgebung. Als Hardware dient eine Synology NAS DS1621+ mit DSM 7 – die Befehle funktionieren aber überall, wo Docker und Node.js laufen.

Um diese Anleitung verständlicher zu machen, begleiten dich drei Personen:
Die typischen Büro-Charaktere: Die kompetente IT-Kollegin, der selbsternannte Experte und der ehrliche Anfänger. Diese drei Perspektiven helfen dir, typische Stolperfallen zu erkennen.

Tanja ist die IT-Expertin. Sie weiß, wie es funktioniert, erklärt geduldig und strukturiert – und lässt sich von schlechten Ratschlägen nicht aus der Ruhe bringen. Wenn du eine Frage hast, hat Tanja die Antwort.

Bernd ist der selbsternannte „Experte“, der alles besser weiß – und meistens falsch liegt. Seine Abkürzungen und sein Halbwissen führen regelmäßig zu Problemen. Er steht für alle gefährlichen Mythen und schlechten Praktiken, die du vermeiden solltest.

Ulf ist der Lernende, genau wie du. Er stellt die Fragen, die dir im Kopf herumschwirren, und braucht manchmal einen Vergleich aus dem Alltag, um IT zu verstehen. Wenn Ulf etwas nicht versteht, ist das völlig in Ordnung, dafür ist Tanja da.

„Und… Action!“

Montagmorgen, 9:14 Uhr. Bernd steht am Drucker, in der einen Hand ein Stück Papier, in der anderen einen halbleeren Kaffeebecher. Auf dem Papier eine Kreditkartenabrechnung. Bernds Gesichtsfarbe wechselt von gesund zu leicht ungesund.

Bernd: „Vierhundertzweiundzwanzig Euro? Für was?“
Tanja: „Für deinen Agenten. Du hast ihn letzten Monat ‚alles dauerhaft mitschreiben‘ lassen.“
Bernd: „Aber ich hab doch gar nicht so viel gemacht.“
Tanja: „Du nicht. Der Agent schon. Heartbeat alle dreißig Sekunden, Memory-Update nach jeder Antwort, drei Recherchen, weil ihm eine Quelle nicht reichte. Das tickt wie ein Taxameter, auch wenn niemand im Auto sitzt.“
Ulf: „Ist das so wie beim Stadionbier? Du trinkst einen Schluck und vergisst, dass jeder Schluck sechs Euro kostet?“
Tanja: „Sehr ähnlich. Und genauso teuer.“

Genau dieses Taxameter schalten wir in dieser Anleitung ab. Nicht durch Verzicht, sondern durch ein anderes Bezahlmodell und ein paar saubere Disziplinregeln.

Kostenhinweis vorab: Diese Anleitung ersetzt nicht Intelligenz durch Sparsamkeit, sondern variable Pay-per-Token-Kosten durch planbare Flatrates. Statt variabler API-Kosten – bei intensiver Nutzung schnell 150–400 €/Monat – zahlst du feste Monatsbeträge: ChatGPT Plus (~20 €/Monat) für Standardanfragen, Claude MAX (~92–184 €/Monat) für Sonnet/Opus. Wer Claude MAX ohnehin nutzt, drückt die variablen Zusatzkosten im Idealfall auf unter 25 €/Monat. Entscheidend bleibt: Deine tatsächlichen Kosten hängen davon ab, welche Abos du bereits hast und wie diszipliniert das Routing arbeitet.

Der Zielzustand: ein ruhiger Maschinenraum mit zwei Kostenbremsen

Bevor wir loslegen, lohnt sich der Blick auf das fertige Bild. Wer weiß, wo er hin will, übersieht unterwegs keine Abzweigung.

Tanja: „Stell dir die heutige Situation wie eine Autovermietung vor, bei der jeder Kilometer einzeln abgerechnet wird – inklusive der Strecke, die das Auto nachts allein um den Parkplatz fährt. Das Zielbild ist ein Monatsabo, bei dem das Auto die Stadtfahrten erledigt, und ein zweites Auto, das nur dann aus der Garage rollt, wenn wirklich Autobahn ansteht.“
Ulf: „Und der Rest der Zeit?“
Tanja: „Steht in der Garage. Kostet nix extra.“
Bernd: „Ich würd einfach mehr Geld verdienen.“
Tanja: „Bernd, das ist kein Geschäftsmodell, das ist Wunschdenken.“

Flatrate statt Taxameter:

• OpenClaw beantwortet Alltagsanfragen standardmäßig über ChatGPT Plus (~20 €/Monat Flatrate) – nicht über Pay-per-Token.
• Für schwere Textarbeit, Architekturfragen und Debugging steht Claude Sonnet/Opus über einen lokalen Proxy bereit (Claude MAX Flatrate).
• Anthropic-Pay-per-Token-Kosten sinken im Zielbild auf unter 5 €/Monat: der API-Key ist der Notausgang, nicht mehr die Hauptstraße.

Token sparen als zweiter Boden:

• SOUL.md und Memory-Dateien sind auf das Nötigste gekürzt – kein überflüssiger Kontext beim Session-Start.
• .clawignore hält Synology-Systemverzeichnisse und Memory-Archive aus dem Workspace des Agenten.
• Eine Rate-Limit-Regel in SOUL.md stoppt Schleifen, bevor sie unbemerkt Kosten aufbauen.
• Heartbeat-Intervall angepasst, damit Idle-Checks nicht unnötig Token verbrennen.

Infrastruktur:

• Der Container läuft autark: kein zweiter Rechner, kein provisorisches Kabel quer durch den Datenpfad.
• Wende startet nach einem Container-Host-Neustart automatisch – konfiguriert über den Aufgabenplaner (DSM) oder einen vergleichbaren Init-Mechanismus.

Voraussetzungen

Ulf: „Brauche ich jetzt einen Doktortitel in Informatik?“
Tanja: „Nein. Ein bisschen SSH, ein bisschen Geduld, eine NAS oder ein Linux-Host. Den Rest erkläre ich dir.“
Bernd: „Ich brauch keine Voraussetzungen, ich klick mich da durch.“
Tanja: „Bernd, dieser Satz steht auf deinem Grabstein. Lies mit.“

Platzhalter in dieser Anleitung:

• <NAS-IP> → deine Host-IP-Adresse (z.B. 192.168.2.10)
• <dein-nutzer> → dein nicht-root-Benutzer-Account auf dem Host mit Docker-Rechten (auf Synology z.B. admin oder ein selbst angelegter Nutzer)

Du kannst beide einmalig als Shell-Variablen setzen:

NAS_IP=192.168.2.10      # hier deine Host-IP
NUTZER=dein-benutzername  # hier deinen Nutzernamen

In den Beispielen dieser Anleitung stehen immer die Platzhalter – ersetze sie durch deine Werte.

Bevor du anfängst, stelle sicher, dass du Folgendes hast:

Host-System und Docker

• Ein Rechner oder NAS mit laufendem Docker (getestet auf Synology DS1621+ mit DSM 7.x – andere Linux-Hosts mit Docker funktionieren analog)
• SSH-Zugang zum Host mit einem normalen Benutzer-Account (kein root – in dieser Anleitung <dein-nutzer>genannt, siehe Kasten oben)
• Docker Compose verfügbar (docker compose oder docker-compose)
• Mac oder PC im selben Netzwerk für die initiale Claude-Browser-Anmeldung

Synology-spezifisch: Wer DSM nutzt, öffnet den Container Manager über DSM → Container Manager. Alle Docker-Befehle per SSH laufen identisch. Pfade wie /volume1/docker/ gelten für das primäre Synology-Volume – passe sie an dein Volume an, falls abweichend.

Laufendes OpenClaw

• OpenClaw bereits als Docker-Container installiert und grundlegend konfiguriert
• Container-Name: openclaw-bernd (passe ihn in allen Befehlen an, wenn deiner anders heißt)
• Verzeichnis auf dem Host: /volume1/docker/openclaw/ (Synology-Beispiel; bei anderen Hosts z.B. /opt/docker/openclaw/)
• Web-UI erreichbar via SSH-Tunnel: ssh -L 18789:127.0.0.1:18789 <dein-nutzer>@<NAS-IP>

Abonnements

• ChatGPT Plus (~20 €/Monat) – für Phase 2
• Claude MAX (~92–184 €/Monat) – für Phase 3

Rechtlicher Hinweis: Phase 3 dieser Anleitung (Claude MAX über lokalen Proxy) nutzt das Claude-MAX-Abo auf eine Weise, die möglicherweise Anthropics Nutzungsbedingungen widerspricht. Du übernimmst dieses Risiko selbst. Im schlimmsten Fall kann Anthropic das Abo sperren. Die Anleitung ist ein Erfahrungsbericht, keine offiziell unterstützte Lösung.

Wissen

• Grundlegende SSH-Kenntnisse (Befehle eingeben, Dateien kopieren)
• Du weißt, wie man in DSM den Container Manager und den Aufgabenplaner öffnet

Die vier Phasen: vom offenen Wasserhahn zum kontrollierten Ventil

Ulf: „Vier Phasen? Klingt nach Champions League: Achtelfinale, Viertelfinale, Halbfinale, Finale.“
Tanja: „Ungefähr. Wobei du dieses Mal in keiner Phase rausfliegst – höchstens stolperst. Und stolpern ist okay, dafür gibt’s Backups.“

Phase	Was passiert
Phase 1	OpenClaw aktualisieren, damit mehrere Provider sauber nebeneinander leben können
Phase 2	ChatGPT Plus als günstiges Standardmodell einrichten
Phase 3	Claude MAX via Wende als lokale Hochleistungs-Abzweigung anbinden
Phase 4	Token-Sparmaßnahmen aktivieren, damit der Agent nicht mit offenem Kofferraum fährt

Wenn du nur wissen willst, wie die fertige Maschine aussieht, springe direkt zu Das fertige Setup auf einen Blick. Wenn du nachbauen willst, arbeite die Phasen der Reihe nach ab. Diese Reihenfolge ist kein Dekor, sondern Teil der Fehlervermeidung.

Phase 1 – OpenClaw aktualisieren

Zuerst wird der Boden gewischt, bevor neue Kabel gelegt werden. Ältere OpenClaw-Versionen (vor 2026.5.7) haben einen Bug, der verhindert, dass mehrere Provider gleichzeitig sauber konfiguriert werden. Dieser Schritt beseitigt ihn – und erspart dir später die Art von Fehler, die aussieht wie Konfiguration, aber riecht wie Spuk.

Bernd: „Updates sind doch eh meistens kaputt. Ich überspring das.“
Tanja: „Wenn du Phase 1 überspringst, scheitert Phase 3 ohne sichtbaren Grund. Du würdest dann zwei Stunden im falschen Wald suchen.“
Ulf: „Wie ein Auswärtsspiel ohne Trikot – kann man machen, aber man fällt auf.“
Tanja: „Genau.“

Schritt 1.1 – Container stoppen

Öffne DSM → Container Manager → Container. Wähle openclaw-bernd und klicke auf Stopp.

Alternativ per SSH:

ssh <dein-nutzer>@<NAS-IP>
cd /volume1/docker/openclaw
sudo docker compose stop openclaw-bernd

Erwartetes Ergebnis: Der Container-Status wechselt auf Beendet.

Schritt 1.2 – Backup anlegen

Wichtig: Führe diesen Schritt immer durch, bevor du Konfigurationsdateien änderst. Backups sind in diesem Setup keine höfliche Empfehlung, sondern der Airbag. Man bemerkt sie erst, wenn man sie braucht – dann aber sehr.

Bernd: „Backups mach ich nie. Hat noch nie geknallt.“
Tanja: „Das stimmt nicht. Letztes Quartal hast du die config.json überschrieben und drei Stunden gebraucht, um sie aus dem Gedächtnis zu rekonstruieren.“
Bernd: „…aber ich hab’s geschafft.“
Tanja: „Ja, weil ich daneben saß.“

ssh <dein-nutzer>@<NAS-IP>
TS=$(date +%Y%m%d-%H%M%S)
mkdir -p /volume1/docker/openclaw/backups/pre-update-$TS
cp /volume1/docker/openclaw/config/openclaw.json \
   /volume1/docker/openclaw/backups/pre-update-$TS/
cp /volume1/docker/openclaw/compose.yaml \
   /volume1/docker/openclaw/backups/pre-update-$TS/
echo "Backup unter /volume1/docker/openclaw/backups/pre-update-$TS"

Der Trick ist die Variable TS mit einem Zeitstempel. Sie sorgt dafür, dass jedes Backup einen eindeutigen Namen hat. Du kannst dieses Snippet beliebig oft ausführen, ohne dir alte Versuche zu überschreiben.

Schritt 1.3 – Image aktualisieren

In DSM → Container Manager → Container, klicke oben rechts auf Einstellungen → Compose-Datei bearbeiten und prüfe, welches Image verwendet wird. Dann:

Variante A (DSM-UI): Container Manager → Registrierung → Image suchen → Aktualisieren

Variante B (SSH):

cd /volume1/docker/openclaw
sudo docker compose pull
sudo docker compose up -d

Schritt 1.4 – Version prüfen

sudo docker exec openclaw-bernd node /app/openclaw.mjs --version

Erwartetes Ergebnis: 2026.5.7 oder neuer.

Schritt 1.5 – Logs auf Fehler prüfen

sudo docker logs openclaw-bernd --tail 50

Wenn du diese Zeile siehst, ist der Bug noch aktiv – das Image wurde nicht korrekt aktualisiert:

Cannot access 'ANTHROPIC_MODEL_ALIASES' before initialization

Wenn diese Zeile nicht erscheint, ist Phase 1 abgeschlossen.

Fakten-Check Phase 1: Container stoppen → Backup anlegen → Image aktualisieren → Version prüfen → Logs lesen. Fünf kleine Schritte, kein einziger riskant – aber alle nötig, damit Phase 3 später überhaupt funktioniert.

Kopfnuss: Führe einmalig sudo docker logs openclaw-bernd --tail 50 aus und scrolle die Ausgabe durch. Findest du irgendwo das Wort error, warn oder Cannot? Wenn ja: vor Phase 2 erst klären. Bernd würde an dieser Stelle weitermachen und sich später wundern.

Phase 2 – ChatGPT Plus als Standard-LLM einrichten

Jetzt wird das Taxameter aus dem Alltag entfernt. OpenClaw wird mit deinem ChatGPT-Plus-Abo verbunden, damit der Großteil der normalen Anfragen über die Flatrate läuft – nicht über Pay-per-Token. Die Idee ist schlicht: Das günstige Modell fährt die Kurzstrecke, Claude kommt erst auf die Autobahn.

Ulf: „Heißt das, das günstige Modell ist schlechter?“
Tanja: „Es ist schlanker. Für ‚Wie spät ist es im Büro nebenan?‘ brauchst du keinen Doktoranden. Für ‚Bau mir die komplette Auth-Architektur mit OAuth, JWT und Rate-Limiter‘ schon.“
Bernd: „Ich nehm immer das Beste. Sicher ist sicher.“
Tanja: „Du nimmst auch immer ein Vierersteak, wenn du zum Bäcker gehst. Und wunderst dich, warum die Rechnung wehtut.“

Schritt 2.1 – OAuth-Anmeldung im Container

Dieser Schritt muss interaktiv im Container-Terminal durchgeführt werden. OpenClaw zeigt einen Browser-Link, den du auf deinem Mac bestätigst. Ja, es fühlt sich kurz an wie ein Sicherheitsritual aus den Nullerjahren. Genau so soll es sein.

Öffne ein Terminal und verbinde dich per SSH mit der NAS. Dann:

sudo docker exec -it openclaw-bernd bash

Im Container:

node /app/openclaw.mjs onboard --flow quickstart --auth-choice openai-codex-device-code

Der Wizard fragt dich der Reihe nach. Hier die exakte Tastaturfolge:

Prompt	Eingabe
Sicherheitsabfrage (y/n)	y + Enter
„Use existing values?“	Enter (Standard übernehmen)
OAuth-Code erscheint	Im Browser auf deinem Mac öffnen und bestätigen
Channel-Auswahl	telegram + Enter
„Telegram already configured?“	Pfeil-Runter + Enter (= Skip / leave as-is)
Web-Search	skip + Enter
Skills einrichten?	n + Enter
Hooks	Leertaste (anhaken) + Enter = Skip
Bot einrichten?	Pfeil-Runter + Enter (= Do this later)

Am Ende erscheint: Onboarding complete.

Wichtig: Klicke vor jedem Tastendruck ins Terminal-Fenster – manche Container-Manager-UIs interpretieren Pfeiltasten sonst als Fensteraktion.

Verlasse den Container:

exit

Schritt 2.2 – Default-Modell korrekt setzen

Das ist der kritischste Schritt der ganzen Phase. OpenClaw setzt nach dem Wizard oft ein Modell als Default, das auf ChatGPT Plus nicht verfügbar ist (gpt-5.5). Dann passiert das Gemeinste, was Software tun kann: Sie fällt still zurück auf Anthropic. Du siehst weiter Antworten. Nur die Rechnung sieht plötzlich wieder aus wie vorher.

Bernd: „Stiller Fallback klingt doch sympathisch. So wie ein Kollege, der einspringt, ohne zu nörgeln.“
Tanja: „Ein Kollege, der dir am Monatsende dreihundert Euro berechnet, ohne zu fragen. Sympathisch?“
Bernd: „…anders ausgedrückt: nein.“
Ulf: „Also wie ein heimlicher Wechsel vom Stehplatz auf die Loge, und der Verein schickt dir dann die Rechnung.“
Tanja: „Perfekt formuliert.“

Prüfe das aktuelle Default-Modell:

sudo docker exec openclaw-bernd node /app/openclaw.mjs models list --json | grep -A2 '"default"'

Setze das korrekte Default-Modell:

sudo docker exec openclaw-bernd openclaw models set openai-codex/gpt-5.4-mini
sudo docker exec openclaw-bernd openclaw models status

Warum genau gpt-5.4-mini? ChatGPT Plus gibt über den OAuth-Codex-Pfad nur dieses eine Modell frei. Größere Modelle (gpt-5.4-pro, gpt-5.5) erscheinen im Dropdown, scheitern aber zur Laufzeit mit [assistant turn failed before producing content] – das ist ein bekannter OpenAI-Fehler (GitHub openai/codex#19654).

ChatGPT-Abo-Übersicht für diesen Setup:
| Abo | Preis | Via Codex-Flow verfügbar |
|—|—|—|
| ChatGPT Plus | ~20 €/Monat | gpt-5.4-mini |
| ChatGPT Pro | ~100–200 €/Monat | stärkere Modelle (GPT-5.5 u.a.) |

Wer über den Codex-OAuth-Pfad stärkere GPT-Modelle nutzen möchte, braucht ein ChatGPT-Pro-Abo. Für die meisten Alltagsanfragen reicht gpt-5.4-mini aber völlig aus – die wirklich komplexen Aufgaben übernimmt ohnehin Claude Sonnet/Opus via Phase 3.

Modell-Routing als Agentenregel festlegen

Die technische Konfiguration allein reicht nicht. Ein Agent ohne Routing-Regel ist wie ein Fahrer ohne Gangschaltung: Er nimmt gern den lautesten Motor, auch zum Brötchenholen. Deshalb braucht SOUL.md eine klare Regel, wann das günstige Standardmodell genügt und wann Claude Sonnet/Opus wirklich antreten darf.

Ulf: „Also stehen die Regeln in einer Textdatei?“
Tanja: „Genau. Der Agent liest sie zu Beginn jeder Session wie ein Spielführer, der vor dem Anpfiff den Mannschaftsbogen liest.“

Ergänze in SOUL.md:

MODELL-ROUTING-REGEL

Standard (Default-Modell):
- Normale Chats, Statusfragen, einfache Automationen,
  Zusammenfassungen, kleine Recherchen

max-sonnet nur für:
- komplexes Debugging
- Architekturentscheidungen
- schwierige Schreib- oder Konzeptarbeit
- mehrstufige technische Planung
- Aufgaben, bei denen das Standardmodell sichtbar nicht ausreicht

max-opus nur für:
- besonders schwierige Analyse
- finale Review wichtiger Texte
- komplexe strategische Entscheidungen

Wenn unklar: erst Standardmodell, nur bei Bedarf eskalieren.

Schritt 2.3 – Container neu starten

cd /volume1/docker/openclaw
sudo docker compose restart openclaw-bernd

Schritt 2.4 – Smoke-Test

Schicke über Telegram oder die Web-UI eine kurze Nachricht an deinen Bot. Prüfe dann die Logs:

sudo docker logs openclaw-bernd --tail 30 | grep -i "openai\|codex\|gpt"

Du solltest openai-codex oder gpt-5.4-mini in den Log-Zeilen sehen.

Schritt 2.5 – 24-Stunden-Check (wichtig!)

Warte einen Tag, dann prüfe das Anthropic-Dashboard unter console.anthropic.com → Usage. Der Token-Verbrauch sollte nahe null sein.

Wenn du dort weiterhin Verbrauch siehst: OpenClaw fällt still auf Anthropic zurück. Das passiert, wenn das Default-Modell nicht korrekt gesetzt wurde. Wiederhole Schritt 2.2.

Bernd: „Einen ganzen Tag warten? Ich bin doch kein Geduldspatient.“
Tanja: „Das ist kein Geduldsspiel, das ist Messmethodik. Wer nach fünf Minuten Schlüsse zieht, sieht die Schleifen nicht, die nachts auftreten.“

Fakten-Check Phase 2: OAuth-Anmeldung → richtiges Default-Modell (gpt-5.4-mini) → Routing-Regel in SOUL.md → Smoke-Test → 24h-Check. Erst wenn alle fünf stimmen, gilt Phase 2 als abgeschlossen.

Kopfnuss: Schreib dir den 24h-Check in den Kalender, mit Erinnerung. Wer ihn vergisst, merkt eine schiefe Konfiguration erst Wochen später – an der Kreditkartenabrechnung. Bernd hat das schon zweimal so erlebt. Du musst es nicht.

Phase 3 – Claude MAX via Wende einrichten

Für anspruchsvollere Aufgaben brauchst du Claude Sonnet oder Opus: für Texte mit Substanz, Debugging mit Tiefgang, Entscheidungen mit mehr als zwei beweglichen Teilen. Ein direkter Proxy ist dafür nicht mehr zuverlässig, weil Anthropic seit März/April 2026 Drittanbieter-Requests für diese Modelle blockiert – erkennbar am Fehler 401 invalid x-api-key.

Die Lösung heißt Wende: ein Node.js-Proxy, der die offizielle claude-CLI als Unterprozess startet. Für Anthropic sieht das nicht nach improvisierter Hintertür aus, sondern nach dem offiziellen Claude-Code-Client. Wende ist damit weniger Tunnelbohrer als Dolmetscher: OpenClaw spricht OpenAI-kompatibel, Wende übersetzt in Claude CLI.

Ulf: „Dolmetscher? Wie beim Auswärtsspiel in der Conference League, wenn der Schiedsrichter Italienisch redet und der Trainer nur Bayerisch versteht?“
Tanja: „Sehr treffend. Ohne den Dolmetscher endet das Spiel im Chaos oder gar nicht.“
Bernd: „Ich würd Anthropic einfach anschreiben und um Ausnahme bitten.“
Tanja: „Du würdest auch versuchen, mit dem Schiedsrichter über die Abseitsregel zu diskutieren. Wende ist die saubere Lösung – kein Wunsch, sondern eine Architektur.“

Hinweis zum Risiko: Die Nutzung des Claude-MAX-Abos über einen lokalen Proxy widerspricht möglicherweise Anthropics Nutzungsbedingungen. Du übernimmst dieses Risiko selbst. Im schlimmsten Fall kann Anthropic das Abo sperren.

Schritt 3.1 – Node.js auf der NAS prüfen

ssh <dein-nutzer>@<NAS-IP>
node --version

Erwartetes Ergebnis: v20.x.x oder neuer. Falls Node.js fehlt, installiere es über das Synology Package Center (Community-Pakete) oder via npm-Quellen – das sprengt den Rahmen dieser Anleitung.

Schritt 3.2 – Verzeichnis für Wende anlegen

sudo mkdir -p /volume1/docker/wende
sudo chown <dein-nutzer>:users /volume1/docker/wende

Schritt 3.3 – Wende einrichten

Wende ist ein Fork von atalovesyou/claude-max-api-proxy. Je nach Repo-Stand gibt es zwei Varianten:

Variante A – Du hast einen fertigen Wende-Bundle (mit vorhandener start-proxy-wende.mjs)

Falls du bereits ein Verzeichnis mit start-proxy-wende.mjs und dist/ hast (z.B. von einem Mac, auf dem Wende bereits lief), kopiere es direkt auf die NAS:

scp -r /pfad/zu/deinem/wende-verzeichnis/* <dein-nutzer>@<NAS-IP>:/volume1/docker/wende/

Prüfe auf der NAS:

ssh <dein-nutzer>@<NAS-IP>
ls /volume1/docker/wende/start-proxy-wende.mjs   # muss existieren
ls /volume1/docker/wende/dist/                    # muss existieren
cd /volume1/docker/wende && npm install           # native Module für NAS bauen

Variante B – Du klonst das Upstream-Repo neu

# Auf dem Mac oder einem Gerät mit git + Node.js:
git clone https://github.com/atalovesyou/claude-max-api-proxy /tmp/wende
cd /tmp/wende
npm install

Prüfe, ob npm run build existiert:

cat package.json | grep '"build"'

Falls ja:

npm run build
ls /tmp/wende/start-proxy-wende.mjs   # muss jetzt existieren
ls /tmp/wende/dist/

Falls nein (kein build-Script):

ls /tmp/wende/*.mjs   # start-proxy-wende.mjs liegt dann direkt im Root

Dann auf die NAS kopieren und dort nochmals npm install ausführen (wie in Variante A).

Kritischer Check in beiden Varianten: Die Datei start-proxy-wende.mjs muss auf der NAS vorhanden sein, bevor du mit Schritt 3.8 weitermachst. Ohne sie startet Wende nicht.

Erwartete Dateistruktur nach erfolgreichem Setup:

/volume1/docker/wende/
  start-proxy-wende.mjs     ← Einstiegspunkt (muss vorhanden sein)
  package.json
  package-lock.json
  dist/
    server/
      index.js              ← kompilierter Server-Code
  node_modules/             ← entsteht nach npm install
  wende.log                 ← entsteht beim ersten Start

Schritt 3.4 – Sicherheitshinweis: Port nur im LAN

Wende startet auf 0.0.0.0:3457 und ist damit im gesamten lokalen Netzwerk erreichbar. Dieser Port darf unter keinen Umständen ins Internet weitergeleitet werden.

Das ist der Moment, an dem aus Technik plötzlich Hausordnung wird: Wende ist OpenAI-kompatibel. Jeder, der Zugriff auf den Port hat, kann über dein Claude-MAX-Abo Anfragen stellen. Der Dummy-Key später in OpenClaw ist kein Türschloss, sondern eher ein Namensschild.

Bernd: „Ich öffne den Port. Nur kurz. Zum Testen.“
Tanja: „Bernd. Wenn du den Port öffnest, hast du innerhalb von 24 Stunden eine API-Rechnung von jemandem aus dem Internet, der dein Abo leerfährt. Nicht ‚vielleicht‘. ‚Vermutlich‘.“
Ulf: „Wie ein offenes Stadiontor vor dem Auswärtsspiel?“
Tanja: „Schlimmer. Wie ein offenes Stadiontor mit einem Schild ‚Hier umsonst Bier‘.“

Stelle sicher:

• Kein Port-Forwarding im Router für Port 3457
• Kein Expose nach außen über Cloudflare Tunnel oder ähnliches
• Zugriff ausschließlich aus dem lokalen Netzwerk oder via VPN

Prüfe auf der NAS, ob der Port nur lokal oder netzwerkseitig gebunden ist:

ss -tlnp | grep 3457
# Erwartet: 0.0.0.0:3457 oder 127.0.0.1:3457 – aber niemals im Router freigegeben

Hinweis zur Sicherheit des Proxy-Endpunkts: Wende prüft keinen echten API-Key. Der Dummy-Key, den du später in OpenClaw hinterlegst, schützt den Proxy nicht – er ist für OpenClaw intern, hat aber keinen Einfluss auf Wende. Sicherheit entsteht ausschließlich durch Netzwerkisolation: Wer den Port erreicht, kann über dein Claude-MAX-Abo anfragen. Halte den Port deshalb strikt im LAN.

Schritt 3.5 – Claude CLI auf der NAS installieren

# Als root/sudo (einmalige Installation):
sudo npm install -g @anthropic-ai/claude-code@2.1.141

Prüfen:

which claude
claude --version

Erwartetes Ergebnis: /usr/local/bin/claude und eine Versionsnummer wie 2.1.141.

Schritt 3.6 – Home-Verzeichnis für Claude anlegen

Claude CLI speichert Credentials in einem Home-Verzeichnis. Damit Wende nie als root laufen muss, legen wir ein dediziertes Verzeichnis an:

Ulf: „Warum nicht einfach als root? Geht doch schneller.“
Tanja: „Weil root auf einem Server alles darf. Wenn der Prozess kompromittiert wird, hat der Angreifer freie Hand. Ein normaler Nutzer ist wie ein Spieler ohne Generalvollmacht – kann nicht einfach den ganzen Verein verkaufen.“
Bernd: „Klingt paranoid.“
Tanja: „Klingt nach Erfahrung.“

sudo mkdir -p /volume1/docker/claude-native-home
sudo chown <dein-nutzer>:users /volume1/docker/claude-native-home
sudo chmod 700 /volume1/docker/claude-native-home

Schritt 3.7 – Claude CLI anmelden

Dieser Schritt erfordert einen Browser auf deinem Mac.. Führe den Login als Benutzer <dein-nutzer> aus:

ssh <dein-nutzer>@<NAS-IP>
HOME=/volume1/docker/claude-native-home claude auth login

Claude öffnet eine URL – kopiere sie und öffne sie im Browser auf deinem Mac. Melde dich mit deinem Claude-MAX-Konto an und bestätige die Anmeldung.

Prüfe, ob die Anmeldung funktioniert hat:

HOME=/volume1/docker/claude-native-home claude --print "Antworte nur mit dem Wort PONG"

Erwartetes Ergebnis: PONG im Terminal. Wenn das klappt, erkennt Anthropic die CLI als echten Claude-Code-Client.

Schritt 3.8 – Port prüfen und ggf. in der Startdatei anpassen

Prüfe zuerst, ob Port 3456 frei ist:

ssh <dein-nutzer>@<NAS-IP>
ss -tlnp | grep 3456

Falls der Port belegt ist (typischerweise durch einen docker-proxy-Prozess auf der NAS), wechsle auf 3457. Ändere den Port aber direkt in der Startdatei – start-proxy-wende.mjs wertet Command-Line-Argumente möglicherweise nicht aus:

grep -n "port\|PORT\|3456" /volume1/docker/wende/start-proxy-wende.mjs | head -20

Suche nach einer Zeile wie const port = 3456 oder PORT=3456 und ändere sie auf 3457:

sed -i 's/const port = 3456/const port = 3457/' /volume1/docker/wende/start-proxy-wende.mjs
# Verifikation:
grep "port" /volume1/docker/wende/start-proxy-wende.mjs | head -5

Merke dir den gewählten Port – du brauchst ihn für die OpenClaw-Konfiguration.

Schritt 3.9 – Wende manuell starten und testen

Jetzt wird aus Konfiguration ein lebender Prozess. Starte Wende zuerst manuell – nicht per Autostart, nicht per Hoffnung, sondern sichtbar und überprüfbar:

Ulf: „Warum nicht direkt Autostart?“
Tanja: „Weil wir noch nicht wissen, ob es überhaupt läuft. Wenn ein Auto nicht anspringt, baust du nicht zuerst die Wegfahrsperre ein. Erst zünden, dann automatisieren.“

ssh <dein-nutzer>@<NAS-IP>
HOME=/volume1/docker/claude-native-home \
PATH=/usr/local/bin:$PATH \
nohup /usr/local/bin/node /volume1/docker/wende/start-proxy-wende.mjs \
  > /volume1/docker/wende/wende.log 2>&1 &
echo "Wende gestartet, PID: $!"

Warte 5 Sekunden, dann prüfe die Logs:

tail -20 /volume1/docker/wende/wende.log

Erwartetes Ergebnis in den Logs – die reale Ausgabe sieht so aus:

[Server] Claude Code CLI provider running at http://0.0.0.0:3457
[Server] OpenAI-compatible endpoint: http://0.0.0.0:3457/v1/chat/completions
Proxy ready at http://0.0.0.0:3457/v1/chat/completions

Wenn die Logs leer sind oder sofort enden, hat Wende einen Startfehler. Prüfe, ob start-proxy-wende.mjs und das dist/-Verzeichnis vorhanden sind.

Robuster Funktionstest über /v1/models (zuverlässiger als /health, der nicht immer implementiert ist):

curl -sS http://127.0.0.1:3457/v1/models

Du solltest Modellnamen wie claude-sonnet-4 und claude-opus-4 in der JSON-Antwort sehen.

Wenn curl Connection refused zurückgibt: Wende ist nicht gestartet. Prüfe wende.log auf Fehlermeldungen, insbesondere ob der Port bereits belegt ist (EADDRINUSE).

Schritt 3.10 – OpenClaw konfigurieren

Jetzt erfährt OpenClaw, dass es einen neuen Provider gibt. Das passiert in sechs kleinen Unter-Schritten – jeden einzeln testen, nicht alle auf einmal abfeuern.

Bernd: „Ich mach das in einem Rutsch. Bin doch nicht ungeduldig.“
Tanja: „Du bist nicht ungeduldig, du bist überheblich. Das ist anstrengender.“

Schritt 3.10-A – Backup anlegen (immer zuerst):

sudo docker exec openclaw-bernd sh -c '
TS=$(date +%Y%m%d-%H%M%S)
cp /home/node/.openclaw/openclaw.json \
   /home/node/.openclaw/openclaw.json.bak-pre-wende-$TS
cp /home/node/.openclaw/agents/main/agent/models.json \
   /home/node/.openclaw/agents/main/agent/models.json.bak-pre-wende-$TS
cp /home/node/.openclaw/agents/main/agent/auth-profiles.json \
   /home/node/.openclaw/agents/main/agent/auth-profiles.json.bak-pre-wende-$TS
echo "Backup TS=$TS angelegt"
'

Schritt 3.10-B – Konfig-Pfade ermitteln:
Je nach OpenClaw-Version und Volume-Mount-Konfiguration liegen die wirksamen Dateien nicht zwingend auf dem Host-Dateisystem. Ermittle die echten Pfade im Container, bevor du irgendwas editierst:

sudo docker exec openclaw-bernd sh -c \
  'find /home/node/.openclaw -name "models.json" -o -name "auth-profiles.json" 2>/dev/null'

Falls die Dateien über ein Volume gemountet sind, kannst du sie auf dem Host editieren. Falls nicht, editiere direkt im Container mit docker exec.
Schritt 3.10-C – models.json per Python-Script setzen (copy-paste-sicher, kein manuelles JSON-Editieren):

Ersetze <NAS-IP> durch deine NAS-IP-Adresse:

sudo docker exec openclaw-bernd sh -c 'python3 - <<'"'"'PY'"'"'
import json
from pathlib import Path

NAS_IP = "<NAS-IP>"    # hier anpassen
PORT   = 3457           # hier anpassen falls abweichend

p = Path("/home/node/.openclaw/agents/main/agent/models.json")
d = json.load(open(p)) if p.exists() else {}
d.setdefault("providers", {})
d["providers"]["claude-max-proxy"] = {
  "baseUrl": f"http://{NAS_IP}:{PORT}/v1",
  "api": "openai-completions",
  "models": [
    {
      "id": "claude-sonnet-4",
      "name": "Claude Sonnet (DSM Wende)",
      "input": ["text"],
      "contextWindow": 200000,
      "maxTokens": 8192
    },
    {
      "id": "claude-opus-4",
      "name": "Claude Opus (DSM Wende)",
      "input": ["text"],
      "contextWindow": 200000,
      "maxTokens": 8192
    }
  ]
}
with open(p, "w") as f:
    json.dump(d, f, indent=2)
    f.write("\n")
print("Geschrieben:")
print(json.dumps(d["providers"]["claude-max-proxy"], indent=2))
PY'

Erwartete Ausgabe: der neue claude-max-proxy-Block wird angezeigt. Kein Fehler = Erfolg.
Zu den Werten:

• "input": ["text"] – OpenClaw erwartet ein Array von Modalitäten, nicht eine Zahl
• "maxTokens": 8192 – konservativ gewählt; stabiler als höhere Werte, die Wende nicht immer sauber transportiert
• Modell-IDs müssen claude-sonnet-4 / claude-opus-4 lauten – nicht claude-sonnet-4-6 (Anthropic-API-ID, die Wende nicht kennt)

Schritt 3.10-D – Auth-Eintrag per OpenClaw CLI setzen:

sudo docker exec -it openclaw-bernd node /app/openclaw.mjs \
  models auth paste-token \
  --provider claude-max-proxy \
  --profile-id claude-max-proxy:dummy

OpenClaw fragt interaktiv nach dem Token-Wert. Gib ein: not-needed (oder irgendeinen beliebigen String – Wende ignoriert den Wert, OpenClaw braucht aber einen Eintrag).

sudo docker exec openclaw-bernd node /app/openclaw.mjs \
  models auth order set \
  --provider claude-max-proxy \
  claude-max-proxy:dummy

Schritt 3.10-E – Modell-Aliase setzen (Sonnet und Opus):

sudo docker exec openclaw-bernd node /app/openclaw.mjs \
  models aliases remove max-sonnet || true
sudo docker exec openclaw-bernd node /app/openclaw.mjs \
  models aliases add max-sonnet claude-max-proxy/claude-sonnet-4

sudo docker exec openclaw-bernd node /app/openclaw.mjs \
  models aliases remove max-opus || true
sudo docker exec openclaw-bernd node /app/openclaw.mjs \
  models aliases add max-opus claude-max-proxy/claude-opus-4

Schritt 3.10-F – Konfiguration prüfen (Pflichtcheck):

sudo docker exec openclaw-bernd openclaw models status
sudo docker exec openclaw-bernd openclaw models list

Erwartete Ausgabe (models list):

openai-codex/gpt-5.4-mini          Auth: yes   default
claude-max-proxy/claude-sonnet-4   Auth: yes   alias: max-sonnet
claude-max-proxy/claude-opus-4     Auth: yes   alias: max-opus

Wenn Auth: no erscheint: Schritt 3.10-D wiederholen.
Wenn ein Alias fehlt: Den entsprechenden models aliases add-Befehl aus 3.10-E erneut ausführen.

Schritt 3.11 – Container neu starten und End-to-End-Test

cd /volume1/docker/openclaw
sudo docker compose restart openclaw-bernd

Öffne die OpenClaw Web-UI (via SSH-Tunnel: ssh -L 18789:127.0.0.1:18789 <dein-nutzer>@<NAS-IP>, dann http://localhost:18789).

Wichtig: Das Default-Modell bleibt openai-codex/gpt-5.4-mini. Du wählst Claude im nächsten Schritt manuellfür den Test – das ist kein Dauerwechsel. Setze Claude nicht als Default, sonst läuft jede einfache Anfrage über dein Claude-MAX-Kontingent.

Bernd: „Aber Claude ist doch besser. Ich setz es als Default.“
Tanja: „Und dann fährst du jeden Tag mit dem Ferrari zur Bäckerei. Geht. Ist nur teuer.“

Wähle im Modell-Dropdown Claude Sonnet (DSM Wende) und sende:

Antworte nur mit dem Wort PONG

Erwartetes Ergebnis: PONG. Wenn Claude antwortet und sich auf Nachfrage als claude-sonnet-4-6 identifiziert, funktioniert der gesamte Datenpfad.

Schritt 3.12 – Autostart einrichten

Ein Setup ist erst dann erwachsen, wenn es einen Neustart überlebt. Damit Wende nach einem NAS-Reboot automatisch wieder aufsteht:

1. Öffne DSM → Systemsteuerung → Aufgabenplaner
2. Klicke Erstellen → Ausgelöste Aufgabe → Benutzerdefiniertes Skript
3. Einstellungen:
   • Aufgabenname: Claude Max Wende Autostart
   • Benutzer: <dein-nutzer> (NICHT root – die Claude CLI Credentials liegen in /volume1/docker/claude-native-home, das <dein-nutzer> gehört. Root findet sie dort nicht und schlägt lautlos fehl)
   • Ereignis: Booten
4. Im Tab Aufgabeneinstellungen → Skript ausführen:

HOME=/volume1/docker/claude-native-home \
PATH=/usr/local/bin:$PATH \
nohup /usr/local/bin/node /volume1/docker/wende/start-proxy-wende.mjs \
  > /volume1/docker/wende/wende.log 2>&1 &

5. Speichern – noch nicht auf Ausführen klicken.
   Laufenden Wende-Prozess erst stoppen, damit der Task-Start nicht wegen belegtem Port scheitert:

pkill -f "start-proxy-wende.mjs" || true
sleep 2
ps aux | grep start-proxy-wende | grep -v grep || echo "Wende gestoppt"

6. Jetzt im Aufgabenplaner auf Ausführen klicken.
   Prüfe danach den tatsächlichen Prozess-Eigentümer:

ps aux | grep start-proxy-wende

Die Spalte USER muss <dein-nutzer> zeigen – nicht root. Falls doch root erscheint, hat DSM den Task-Benutzer ignoriert (kommt gelegentlich vor).
Fix-Pfad wenn root erscheint:

• Kein sudo im Skript verwenden
• Task löschen, neu anlegen, Benutzer bei Schritt 3 erneut explizit setzen
• Prüfe vorher, ob <dein-nutzer> überhaupt Zugriffsrechte auf das claude-native-home hat:

ls -ld /volume1/docker/claude-native-home
ls -la /volume1/docker/claude-native-home/.claude 2>/dev/null || echo "Verzeichnis nicht gefunden"

Erwartetes Ergebnis: Owner <dein-nutzer>, Permissions drwx------ (700). Falls Owner root ist, korrigieren:

sudo chown -R <dein-nutzer>:users /volume1/docker/claude-native-home
sudo chmod 700 /volume1/docker/claude-native-home

Prüfe danach mit dem zuverlässigen Test:

curl -sS http://127.0.0.1:3457/v1/models

Schritt 3.13 – Fallback-Kette konfigurieren (optional)

Hinweis: Die folgenden Config-Pfade (routing.fallback.*) existieren nicht in allen OpenClaw-Versionen. Prüfe zuerst, ob deine Version sie kennt:

sudo docker exec openclaw-bernd node /app/openclaw.mjs config schema | grep -i fallback

Erscheinen fallback-Einträge in der Ausgabe, kannst du sie setzen:

sudo docker exec openclaw-bernd node /app/openclaw.mjs config set \
  routing.fallback.primary "openai-codex/gpt-5.4-mini"
sudo docker exec openclaw-bernd node /app/openclaw.mjs config set \
  routing.fallback.secondary "claude-max-proxy/claude-sonnet-4"

Erscheint nichts oder gibt der Befehl einen Fehler zurück: Fallback-Kette ist in deiner Version nicht über diese Pfade konfigurierbar – überspringe diesen Schritt.

Fakten-Check Phase 3: Node.js prüfen → Verzeichnis → Wende bauen → Sicherheits-Check (Port nur LAN!) → Claude CLI installieren → Home anlegen → Claude einloggen → Port setzen → manuell starten → OpenClaw konfigurieren (sechs Sub-Schritte) → Container-Restart + Test → Autostart einrichten → optional Fallback. Klingt nach viel, ist aber jeweils ein Mini-Schritt. Wer alle nacheinander macht, schafft Phase 3 in 30–60 Minuten.
Kopfnuss: Führe nach Phase 3 unbedingt den End-to-End-Test aus Schritt 3.11 manuell durch – also: Web-UI öffnen, Claude im Dropdown wählen, „PONG“-Test schicken. Wer diesen Test überspringt, übersieht eine schiefe Konfiguration garantiert. Bernd hat das schon getan und stand zwei Tage später ratlos vor einer Fehlermeldung, die er an Tag eins hätte sehen können.

Phase 4 – Token-Sparmaßnahmen

Jetzt kommt die unspektakuläre, aber entscheidende Arbeit: weniger Gepäck. Diese Maßnahmen sind Provider-unabhängig. Sie reduzieren, wie viel Kontext bei jedem Aufruf mitgeschickt wird – denn Agenten sind erstaunlich gut darin, alte Notizen, halbe Logdateien und historische Missverständnisse wie einen Umzugskarton mitzuschleppen.

Ulf: „Wie ein Stürmer, der immer noch das Trikot vom letzten Verein mit aufs Feld nimmt?“
Tanja: „Genau. Spielt sich schlechter, sieht komisch aus, kostet trotzdem Geld.“
Bernd: „Kontextkürzung klingt nach Aufwand. Ich lass das.“
Tanja: „Du lässt damit auch 30–60 % deiner Tokenkosten liegen. Dein Geld.“

Schritt 4.1 – Startkontext reduzieren

Der Agent lädt bei jeder Konversation seine Regeldatei (SOUL.md). Je kürzer sie ist, desto weniger Token werden verbraucht. Eine gute SOUL.md ist keine Autobiografie, sondern ein präziser Kompass.

nano /volume1/docker/openclaw/workspace/SOUL.md

Was du sicher löschen kannst:

• Doppelte Formulierungen und Wiederholungen
• Ausführliche Erklärungen von Regeln (Stichworte reichen)
• Veraltete Anweisungen
  Was du auf keinen Fall löschen darfst:
• Sicherheits- und Datenschutzregeln
• Verhaltensregeln (was der Agent tun/nicht tun soll)
• Grenzziehungen (z.B. keine sensiblen Daten weitergeben)
  Ziel: 50–80 % Kürzung der Dateigröße ist realistisch.
  Nach jeder Änderung: Teste den Agenten mit einer Standardanfrage, um sicherzustellen, dass er sich noch korrekt verhält.

Session-Start-Regel ergänzen

Der größte versteckte Token-Verbrauch entsteht nicht durch einzelne Antworten, sondern durch zu viel Kontext beim Start jeder Session. Wenn der Agent bei jeder neuen Unterhaltung alte Chat-Historie, komplette Memory-Dateien oder frühere Tool-Ausgaben lädt, entstehen schnell tausende unnötige Input-Tokens – bei jeder einzelnen Anfrage.

Ulf: „Wie wenn der Coach vor jedem Spiel die letzten zehn Saisons noch mal vorliest?“
Tanja: „Treffend. Niemand braucht das. Erst recht nicht, wenn man’s bezahlen muss.“

Ergänze in SOUL.md eine explizite Session-Start-Regel:

SESSION-START-REGEL

Bei jedem Session-Start nur laden:
- SOUL.md
- USER.md
- IDENTITY.md
- memory/YYYY-MM-DD.md, falls vorhanden
Nicht automatisch laden:
- vollständige alte Session-Historie
- komplette MEMORY.md
- alte Tool-Ausgaben und Logs
- archivierte Memory-Dateien
Wenn der Nutzer nach früherem Kontext fragt:
- gezielt suchen
- nur den relevanten Ausschnitt laden
- niemals komplette Archive in den Kontext ziehen
Am Ende wichtiger Sessions:
- kurze Tagesnotiz in memory/YYYY-MM-DD.md schreiben
- Entscheidungen, offene Punkte und nächste Schritte knapp festhalten

Kontext in stabile Kurzdateien aufteilen

Lege wiederverwendbaren Kontext nicht in Chatverläufe, sondern in kleine stabile Dateien. Das verhindert, dass der Agent bei jeder Anfrage wachsende Memory-Blöcke laden muss.

Empfohlene Struktur:

workspace/
  SOUL.md          → Regeln, Verhalten, Sicherheitsgrenzen  (stabil)
  USER.md          → Nutzerinfo, Ziele, Präferenzen          (stabil)
  IDENTITY.md      → Rolle und Aufgabe des Agenten           (stabil)
  TOOLS.md         → Tool-Dokumentation                      (stabil)
  memory/
    YYYY-MM-DD.md  → Tagesnotizen, nur aktuelle Arbeit       (dynamisch)
    archive/       → alte Notizen, nicht automatisch laden

Beispiel für eine schlanke USER.md:

# USER.md
- Zeitzone: Europe/Berlin
- NAS-IP: <NAS-IP>, User: <dein-nutzer>
- OpenClaw-Container: openclaw-bernd
- Wende-Proxy: /volume1/docker/wende, Port 3457
- Bevorzugter Arbeitsstil: Stop-Punkte vor jeder riskanten Aktion, Backup zuerst

Wichtig: Diese Dateien sollen kurz und stabil bleiben. Was selten gebraucht wird, gehört ins Archiv – nicht in den Standardkontext.

Cache-freundliche Kontextstruktur

Statische Dateien sollten sich selten ändern, dynamische Notizen kommen in separate Tagesdateien. Das reduziert Cache-Invalidierung und verhindert, dass kleine Änderungen den gesamten Kontext unnötig verteuern.
Regel:

• SOUL.md, USER.md, IDENTITY.md nicht während einer laufenden Session ändern
• Tagesnotizen in memory/YYYY-MM-DD.md getrennt halten
• Projektunterlagen in REFERENCE.md (stabil) und NOTES.md (dynamisch) trennen
• Große Referenztexte nur laden, wenn sie für die aktuelle Aufgabe nötig sind

Schritt 4.2 – Memory sauber trennen

Alte Memory-Dateien sind einer der größten Kontext-Treiber im Dauerbetrieb. Nutze Tagesnotizen statt einer wachsenden Gesamt-Memory, und verschiebe ältere Einträge regelmäßig ins Archiv:

workspace/memory/
  2026-05-14.md   → aktuelle Tagesnotiz (wird geladen)
  2026-05-15.md   → aktuelle Tagesnotiz (wird geladen)
  archive/        → alles älter als 7–14 Tage (wird NICHT automatisch geladen)

Wenn alter Kontext gebraucht wird, soll der Agent gezielt suchen und nur den relevanten Ausschnitt laden – nicht das gesamte Archiv.
Wie .gitignore für Code verhindert .clawignore, dass der Agent unnötige Verzeichnisse in seinen Workspace zieht. Das ist digitale Diätetik: nicht alles, was auf der Platte liegt, muss in den Kopf des Modells:

cat > /volume1/docker/openclaw/workspace/.clawignore << 'EOF'
# Synology-Systemverzeichnisse
@eaDir/
.synology/
#recycle/

# Memory-Archiv (ältere Einträge)
memory/archive/

# Temporäre Dateien
*.tmp
*.bak.*
EOF

Schritt 4.3 – Heartbeat reduzieren

OpenClaw sendet standardmäßig zu häufige Heartbeat-Checks. Prüfe zuerst, ob deine Version diese Konfigurationspfade kennt:

sudo docker exec openclaw-bernd node /app/openclaw.mjs config schema | grep -i heartbeat

Falls heartbeat.interval und heartbeat.skipWhenBusy erscheinen:

sudo docker exec openclaw-bernd node /app/openclaw.mjs config set \
  heartbeat.interval "1h"
sudo docker exec openclaw-bernd node /app/openclaw.mjs config set \
  heartbeat.skipWhenBusy true

Damit prüft der Agent sich nur stündlich – und nur dann, wenn er gerade keine Aufgabe bearbeitet. Falls die Pfade nicht existieren, überspringe diesen Schritt – der Heartbeat läuft dann auf Default-Intervall, was in der Praxis meist akzeptabel ist.
Optional: Heartbeats auf ein lokales Modell legen
Wenn dein Setup sehr viele Heartbeats erzeugt, können diese statt über ChatGPT Plus über ein lokales Modell (z.B. Ollama mit llama3.2:3b) laufen – dann entstehen dafür null API-Kosten. Prüfe zuerst, ob deine OpenClaw-Version ein separates Heartbeat-Modell kennt:

sudo docker exec openclaw-bernd node /app/openclaw.mjs config schema | grep -i "heartbeat.*model\|model.*heartbeat"

Erscheint kein Eintrag: diese Option nicht verfügbar, die sparsame Intervall-Variante oben reicht.

Schritt 4.4 – Schleifen und Wiederholungen begrenzen

Viele ungeplante Kosten entstehen nicht durch die eine große Antwort, sondern durch Schleifen: Der Agent versucht denselben Fehler wieder und wieder, startet Websuchen wie ein nervöser Praktikant oder ruft Modelle in schneller Folge auf. Das ist nicht Intelligenz, das ist ein Hamsterrad mit API-Key.

Bernd: „Wenn der Agent es zwanzigmal probiert, ist das doch fleißig.“
Tanja: „Es ist nicht fleißig. Es ist Verzweiflung. Und Verzweiflung kostet zwanzig Mal.“

Ergänze in SOUL.md:

RATE-LIMIT-REGEL
- Mindestens 5 Sekunden Abstand zwischen Modellaufrufen.
- Mindestens 10 Sekunden Abstand zwischen Websuchen.
- Maximal 5 Websuchen pro Recherche-Batch, danach Ergebnis zusammenfassen.
- Ähnliche Aufgaben bündeln: eine Anfrage für mehrere kleine Punkte,
  keine Einzelanfragen pro Punkt.
- Bei 429, Rate Limit, Timeout oder wiederholtem Auth-Fehler:
  sofort stoppen, Fehler zusammenfassen,
  keine automatischen Wiederholungen ohne Nutzerfreigabe.
- Bei drei gleichartigen Fehlern in Folge:
  Diagnosemodus statt Weiterprobieren.

Diese Regel schützt vor unbemerkten Kostenläufen und macht Fehler schneller sichtbar.

Schritt 4.5 – Container neu starten

cd /volume1/docker/openclaw
sudo docker compose restart openclaw-bernd

Fakten-Check Phase 4: SOUL.md kürzen → Session-Start-Regel → Kontext in stabile Kurzdateien → Memory trennen → .clawignore → Heartbeat reduzieren → Rate-Limit-Regel → Restart. Provider-unabhängig, jeder Schritt klein, in Summe der zweite Boden unter den Flatrate-Einsparungen.
Kopfnuss: Miss einmalig die Größe deiner SOUL.md mit wc -l /volume1/docker/openclaw/workspace/SOUL.md. Wenn die Datei über 200 Zeilen hat, ist sie zu lang. Kürze sie auf maximal 100 Zeilen – jede überflüssige Zeile kostet bei jeder einzelnen Session Tokens. Bernd hat seine SOUL.md zwei Jahre lang nicht gepflegt. Tu’s nicht wie Bernd.

Wartung – die kleinen Rituale gegen große Rechnungen

Ein System, das einmal läuft, läuft nicht für immer. Es läuft, bis das nächste Token abläuft, der nächste API-Endpunkt sich ändert oder das nächste DSM-Update kommt. Wartung ist keine Strafe, sondern Versicherung.

Ulf: „Wartung klingt nach Werkstatt.“
Tanja: „Ist es auch. Aber alle drei Wochen kurz Ölstand prüfen ist günstiger als einmal im Jahr Motor tauschen.“

Claude CLI Token-Ablauf (alle paar Wochen)

Die Claude-CLI-Anmeldung läuft ohne Vorwarnung ab. Nicht dramatisch, aber hinterhältig. Symptom: Wende antwortet mit Not logged in oder Authentication error.
Fix:

ssh <dein-nutzer>@<NAS-IP>
HOME=/volume1/docker/claude-native-home claude auth login

Erneut Browser-Link öffnen und bestätigen. Danach Wende neu starten:

pkill -f "start-proxy-wende.mjs"
HOME=/volume1/docker/claude-native-home \
PATH=/usr/local/bin:$PATH \
nohup /usr/local/bin/node /volume1/docker/wende/start-proxy-wende.mjs \
  > /volume1/docker/wende/wende.log 2>&1 &

Empfehlung: Richte einen Kalender-Reminder alle 3 Wochen ein, um den Status zu prüfen.

ChatGPT OAuth Token-Ablauf (alle 4–8 Wochen)

Symptom: Telegram-Bot antwortet nicht mehr oder Anfragen landen wieder bei Anthropic.
Fix: Wiederhole Schritt 2.1 (OAuth-Onboarding im Container). Das neue Token ersetzt das alte automatisch.

Modell-IDs überprüfen

Anthropic und OpenAI ändern gelegentlich verfügbare Modell-IDs. Prüfe bei seltsamen Fehlern:

sudo docker exec openclaw-bernd node /app/openclaw.mjs models list
curl -sS http://127.0.0.1:3457/v1/models

Prüfen, ob die Token-Sparmaßnahmen wirken

Nach den Änderungen solltest du nicht nur testen, ob der Bot antwortet, sondern ob er wirklich sparsamer arbeitet.

sudo docker exec openclaw-bernd node /app/openclaw.mjs models status
sudo docker exec openclaw-bernd node /app/openclaw.mjs models list

Achte auf:

• Default zeigt auf das günstige Standardmodell (openai-codex/gpt-5.4-mini)
• max-sonnet zeigt auf claude-max-proxy/claude-sonnet-4
• max-opus zeigt auf claude-max-proxy/claude-opus-4
• Keine unerwarteten Fallbacks auf Anthropic API
• Heartbeat läuft selten
• Alte Memory-Archive werden nicht automatisch geladen
  Nach 24 Stunden prüfen:
• Anthropic API Usage → sollte nahe null sein (Claude läuft über Wende/CLI, nicht über deinen Anthropic API-Key – Claude-MAX-Nutzung ist dort nicht sichtbar)
• OpenAI/Codex-Nutzung → sollte den Hauptanteil zeigen
• Wende-Log auf Dauerschleifen oder wiederholte Fehler: tail -50 /volume1/docker/wende/wende.log
• OpenClaw-Logs auf Timeouts und Fallbacks: sudo docker logs openclaw-bernd --tail 100 | grep -i "fallback\|timeout\|error"
  Wenn die Kosten nicht sinken, liegt es fast immer an einem dieser Punkte:
• Falsches Default-Modell gesetzt (Schritt 2.2 prüfen)
• Stiller Fallback auf Anthropic aktiv (Schritt 2.5 wiederholen)
• Startkontext zu groß (SOUL.md, Memory-Archive, Session-Start-Regel)
• Heartbeat oder Automationen laufen zu häufig
• Rate-Limit-Schleifen erzeugen unbemerkt viele Anfragen

Rollback – zurück auf festen Boden

Wenn nach Schritt 3.10 etwas nicht stimmt, ist das kein Weltuntergang. Genau dafür gab es die Backups. Du kannst die Konfiguration vollständig auf den Stand vor der Wende-Einrichtung zurücksetzen:

Ulf: „Das ist wie die Halbzeitansprache des Trainers, wenn nichts läuft – einfach auf das alte System zurück.“
Tanja: „Exakt. Und es ist überhaupt keine Schande, das zu tun. Wer rollbackt, gewinnt Zeit für die Fehleranalyse.“

# Im Container: neuestes Backup finden
sudo docker exec -it openclaw-bernd sh -c '
  echo "openclaw.json Backup:"
  ls -t /home/node/.openclaw/openclaw.json.bak-pre-wende-* 2>/dev/null | head -1
  echo "models.json Backup:"
  ls -t /home/node/.openclaw/agents/main/agent/models.json.bak-pre-wende-* 2>/dev/null | head -1
'

Dann die gewünschten Backups einspielen (Pfade aus der Ausgabe oben einsetzen):

sudo docker exec openclaw-bernd sh -c '
  cp /home/node/.openclaw/openclaw.json.bak-pre-wende-<TIMESTAMP> \
     /home/node/.openclaw/openclaw.json
  cp /home/node/.openclaw/agents/main/agent/models.json.bak-pre-wende-<TIMESTAMP> \
     /home/node/.openclaw/agents/main/agent/models.json
  echo "Rollback abgeschlossen"
'
sudo docker restart openclaw-bernd

Nach dem Neustart ist OpenClaw wieder im Zustand vor der Wende-Konfiguration.

Troubleshooting – wenn der Maschinenraum hustet

Bernd: „Bei mir läuft eh nix wie geplant.“
Tanja: „Dann ist diese Tabelle für dich gemacht. Erst Symptom suchen, dann Lösung anwenden – nicht zuerst alles auseinandernehmen.“

Symptom	Ursache	Lösung
Cannot access 'ANTHROPIC_MODEL_ALIASES' in Logs	Alte OpenClaw-Version	Phase 1 erneut ausführen
[assistant turn failed before producing content]	Falsches ChatGPT-Modell (z.B. gpt-5.5)	Schritt 2.2 wiederholen, gpt-5.4-mini setzen
Wende antwortet Not logged in	Claude CLI Token abgelaufen	Abschnitt „Wartung“ oben
Wende startet nicht	Falscher Benutzer (root statt )	DSM Aufgabenplaner-Task prüfen: Benutzer =
Port 3457 belegt	Prozess vom letzten Start läuft noch	pkill -f start-proxy-wende.mjs, dann neu starten
OpenClaw-Container startet nicht nach JSON-Änderung	Syntaxfehler in openclaw.json	JSON auf jsonlint.com prüfen, Backup einspielen
Anthropic-Kosten nach dem Wechsel weiterhin hoch	Stiller Fallback auf Anthropic	Schritt 2.5 (24h-Check) und Default-Modell prüfen
401 invalid x-api-key bei Sonnet/Opus	Anthropic-Fingerprinting-Block (seit März 2026)	Wende muss als CLI-Subprocess laufen – Konfiguration prüfen

Quick Verification – läuft die Maschine wirklich?

Bevor du den Artikel als abgeschlossen betrachtest, führe diese vier Befehle aus. Sie prüfen den gesamten Stack in unter einer Minute. Vertrauen ist gut, curl ist besser.

Ulf: „Wie der Schiri-Check vor dem Anpfiff – Netz, Eckfahnen, Mittelkreis, Bälle?“
Tanja: „Genau. Klingt langweilig, ist aber genau das, was Pannen während des Spiels verhindert.“

# 1. Wende erreichbar und Modelle registriert?
curl -sS http://127.0.0.1:3457/v1/models | python3 -m json.tool | grep '"id"'

# 2. Echter Request durch Wende → Claude CLI → Anthropic (wichtigster Test)
curl -sS http://127.0.0.1:3457/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-sonnet-4","messages":[{"role":"user","content":"Reply PONG"}],"max_tokens":20}'
# Erwartung: JSON-Antwort mit "PONG" im content-Feld

# 3. Auth-Status pro Modell (models list) und Provider-Übersicht (models status)
sudo docker exec openclaw-bernd openclaw models list
sudo docker exec openclaw-bernd openclaw models status

# 4. ChatGPT als Default? (Claude darf NICHT Default sein)
sudo docker exec openclaw-bernd openclaw models list | grep default

Checkliste – alles muss zutreffen:

• [ ] curl /v1/models gibt claude-sonnet-4 und claude-opus-4 zurück
• [ ] curl /v1/chat/completions (PONG-Test) antwortet mit PONG – Wende + Claude CLI + Auth OK
• [ ] models list zeigt Auth yes für claude-max-proxy/claude-sonnet-4 mit Alias max-sonnet
• [ ] models list zeigt Auth yes für claude-max-proxy/claude-opus-4 mit Alias max-opus
• [ ] models status zeigt einen aktiven Auth-Eintrag für claude-max-proxy
• [ ] default steht bei openai-codex/gpt-5.4-mini – nicht bei einem Claude-Modell
• [ ] Wende-Log (tail -5 /volume1/docker/wende/wende.log) zeigt keinen Fehler
• [ ] Anthropic-Dashboard nach 24 h: Token-Verbrauch nahe null (Claude läuft über Wende/CLI, nicht über deinen Anthropic API-Key)

Wenn alle acht Punkte zutreffen, ist das Setup vollständig und veröffentlichungsreif.

Das fertige Setup auf einen Blick: die Architektur ohne Nebelmaschine

Telegram / OpenClaw Web-UI
  → Standardanfrage: openai-codex/gpt-5.4-mini  (ChatGPT Plus, ~20 €/Monat)
  → Premium-Text:    claude-max-proxy/claude-sonnet-4
       → HTTP POST http://<NAS-IP>:3457/v1/chat/completions
       → Wende (Node.js, /volume1/docker/wende/) auf DSM
       → spawn("claude", ["--print", ...])
       → claude CLI nutzt /volume1/docker/claude-native-home/.claude/credentials.json
       → Prozess-Owner: <dein-nutzer> (nicht root)
       → Anthropic akzeptiert (echte Claude-Code-CLI, kein Fingerprinting-Block)
       → Claude Sonnet/Opus antwortet; je nach Claude-CLI-/Wende-Stand kann sich
         das Modell intern z.B. als Sonnet 4.6 oder Opus 4.7 identifizieren

Monatliche Kosten nach dem Setup:

Posten	Kosten	Anmerkung
ChatGPT Plus	~20 €/Monat	Flatrate, in der EU direkt in Euro abgerechnet
Claude MAX (5x-Tier)	~92 €/Monat	Flatrate, in USD (~100 $), Kurs variiert
Claude MAX (20x-Tier)	~184 €/Monat	Flatrate, in USD (~200 $), Kurs variiert
Anthropic API (Notfall-Fallback)	< 5 €/Monat	Pay-per-Token, nur im Ausnahmefall

Zum Vergleich vorher: Claude Sonnet 4.6 kostet 3 €/Mio. Input-Token und 15 €/Mio. Output-Token über die API. Ein agentischer Dauerbetrieb mit Heartbeat, Memory-Updates und aktivem Telegram-Bot verbraucht schnell mehrere Millionen Token pro Tag – was die 150–400 €/Monat erklärt.

Was „unter 25 € variable Kosten“ bedeutet: Wer Claude MAX bereits als Flatrate hat, zahlt danach im Idealfall nur noch ~20 € für ChatGPT Plus plus einen kleinen Anthropic-Fallback-Anteil. Claude MAX bleibt ein fixer Monatsblock – ärgerlich, aber planbar. Das eigentliche Ziel ist, das Taxameter aus dem Alltag zu nehmen: nicht jede Nachricht, nicht jeder Heartbeat, nicht jede kleine Statusfrage soll wieder Münzen in den API-Schlitz werfen.

Bernd: „Also doch keine Nullkosten.“
Tanja: „Nein. Planbare Kosten. Das ist viel mehr wert als ‚billig‘.“
Ulf: „Wie eine Saisonkarte statt einzelner Tickets.“
Tanja: „Genau. Du weißt, was du zahlst. Und schläfst nachts besser.“