DeepSeek überall: Ein günstiges Cloud-Gehirn in Claude Code und einen lokalen Agenten-Stack verdrahten

DeepSeek trägt bei mir inzwischen drei verschiedene Dinge: das Gehirn meines Agenten-Stacks, die Claude Code CLI und die Cloud-Sprosse einer Fallback-Leiter. Der gesamte Verdrahtungsaufwand war etwas JSON, ein paar Umgebungsvariablen und ein systemd-Escaping-Bug, der mir einen Abend gekostet hat.

Was am Ende steht

Vor der Anleitung erst die Form des Ganzen. Ich betreibe OpenClaw, ein Agenten-Gateway, mit acht namentlichen Agenten hinter einer Chat-UI, plus der Claude Code CLI, die diese Agenten für echte Coding-Arbeit starten. DeepSeek trägt beides.

Muster	Was es macht	Kosten
1. Agenten-Gehirn	DeepSeek als Provider in der Gateway-Config; jeder Agent kann es als Primärmodell oder Fallback wählen	$0,14–$0,87 / Million Token
2. Claude-Code-Backend	Ein systemd-Drop-in lenkt die CLI auf DeepSeeks Anthropic-kompatiblen Endpoint um, keine Neuinstallation nötig	gleiche Preise pro Token
3. Fallback-Leiter	Eine Entscheidungsliste, wann ein Job zu DeepSeek geht und wann zu einem lokalen Modell	$0, wenn es lokal bleibt

Der eine Satz, der das alles möglich macht: DeepSeek liefert einen Anthropic-kompatiblen Endpoint unter https://api.deepseek.com/anthropic. Alles, was gebaut wurde, um mit Claude zu sprechen — die Claude Code CLI eingeschlossen —, lässt sich mit nichts als Umgebungsvariablen dorthin umlenken. Kein Wrapper-Skript, kein Fork.

Muster 1: DeepSeek als Agenten-Gehirn

Ein Provider-Block in der Gateway-Config. Echtes Ding, Schlüssel geschwärzt:

"deepseek": {
  "baseUrl": "https://api.deepseek.com/v1",
  "api": "openai-completions",
  "apiKey": "CHANGE_ME",
  "timeoutSeconds": 450,
  "models": [
    {
      "id": "deepseek-v4-pro",
      "name": "deepseek-v4-pro",
      "reasoning": true,
      "input": ["text"],
      "cost": { "input": 0.435, "output": 0.87,
                "cacheRead": 0.003625, "cacheWrite": 0.435 },
      "contextWindow": 1000000,
      "maxTokens": 384000
    },
    {
      "id": "deepseek-v4-flash",
      "name": "deepseek-v4-flash",
      "reasoning": true,
      "input": ["text"],
      "cost": { "input": 0.14, "output": 0.28,
                "cacheRead": 0.0028, "cacheWrite": 0.14 },
      "contextWindow": 1000000,
      "maxTokens": 384000
    }
  ]
}

Jeder Agent wählt dann ein Primärmodell und eine Fallback-Kette:

"model": {
  "primary": "deepseek/deepseek-v4-flash",
  "fallbacks": ["deepseek/deepseek-v4-pro", "vllm/google/gemma-4-31b"]
}

So läuft es ab, wenn bei diesem Routing eine Nachricht ankommt:

Meine echte Aufstellung. Die meisten Agenten starten mit DeepSeek und fallen auf lokal zurück; Doxy macht absichtlich das Gegenteil:

Agent	Primärmodell	Fallbacks
Bits (Haupt-Chat)	DeepSeek flash	DeepSeek pro → lokal gemma-4-31b
Brains	DeepSeek pro	lokal gemma-4-31b
Flash	DeepSeek flash	DeepSeek pro → lokal
Hermes (Deploy-Agent)	DeepSeek pro	DeepSeek flash → lokal
Alpha (familienfreundlich)	DeepSeek flash	DeepSeek pro → lokal
Doxy (lokales Arbeitspferd)	lokal 120B	DeepSeek flash (umgekehrt — lokal führt)
beta	lokal	DeepSeek flash → DeepSeek pro
Charley (Bildverarbeitung)	lokal gemma-31b	DeepSeek pro → DeepSeek flash

Hier kommt Charley ins Spiel: Diese DeepSeek-Einträge sind textbasiert ("input": ["text"]), also bleibt Bildarbeit lokal, egal was die Kette sagt. Aliase (ds-flash, ds-brain) lassen mich Modelle mitten im Gespräch tauschen, statt die Config zu bearbeiten.

Zwei Einstellungen beißen dich, wenn du sie überspringst:

• "reasoning": true ist bei Reasoning-Modellen Pflicht. Sie streamen reasoning_content, bevor die eigentliche Antwort kommt; ist das Flag aus, hört das Gateway nur Stille, hält das Modell für hängengeblieben und killt den Turn nach rund 390 Sekunden. Frag nicht, woher ich das weiß.
• Erhöhe timeoutSeconds. Das Standard-Request-Timeout lag bei 120 Sekunden; lange Reasoning-Läufe sprengen das locker und „scheitern" scheinbar zufällig. 450 hat es hier behoben, und Provider-Einstellungen laden per Hot-Reload — kein Gateway-Neustart nötig.

Muster 2: Claude Code CLI auf DeepSeek

Die Claude Code CLI liest ANTHROPIC_BASE_URL, ANTHROPIC_MODEL und ANTHROPIC_AUTH_TOKEN/ANTHROPIC_API_KEY aus ihrer Umgebung, und DeepSeeks /anthropic-Endpoint spricht dasselbe Wire-Format wie Claude. Die CLI umzuleiten heißt also nur, die Umgebung zu ändern, die das Gateway jedem Claude-Code-Subprozess mitgibt, den es startet — die CLI selbst bleibt eine ganz normale Installation.

Die Datei ist ein systemd-User-Drop-in. Meiner wird von einer kleinen selbstgebauten GTK-App erzeugt, die zwischen vier Modi umschaltet (Local LM Studio / DeepSeek / Anthropic Cloud / Off), aber er ist kurz genug, um ihn von Hand zu schreiben:

# ~/.config/systemd/user/openclaw-gateway.service.d/60-subagent-routing.conf
[Service]
# Routes Claude Code CLI sub-processes to DeepSeek's Anthropic-compatible
# endpoint. The key is NOT copied here: $$DEEPSEEK_API_KEY is systemd's escape
# for a literal $DEEPSEEK_API_KEY, which bash expands at runtime from the
# gateway EnvironmentFile -- the secret never enters the unit or the argv.
Environment="ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic"
Environment="ANTHROPIC_MODEL=deepseek-v4-pro"
ExecStart=
ExecStart=/usr/bin/bash -c 'export ANTHROPIC_AUTH_TOKEN="$$DEEPSEEK_API_KEY"; export ANTHROPIC_API_KEY="$$DEEPSEEK_API_KEY"; exec node /path/to/openclaw/dist/index.js gateway --port 18789'

Der Schlüssel selbst lebt an genau einem Ort: der EnvironmentFile des Dienstes (~/.openclaw/gateway.systemd.env, chmod 600), die nur DEEPSEEK_API_KEY=CHANGE_ME enthält.

Die $$-Falle (der ganze Grund, warum dieser Beitrag existiert)

Mein erster Versuch nutzte ein einzelnes $. Das lief nicht gut. In einer Unit-Datei wird $VAR von systemd selbst beim Starten expandiert, was den Schlüssel direkt in die Kommandozeile backt — sichtbar in ps, in /proc/<pid>/cmdline und in systemctl show. Nicht gerade der Ort, an dem ein Secret liegen sollte.

$$VAR ist systemds Escape für ein literales $VAR: systemd reicht die Zeichenkette unangetastet durch, und bash expandiert sie erst zur Laufzeit, aus der Umgebung, die die EnvironmentFile schon befüllt hat. Netto-Effekt: Das Secret existiert in genau einer chmod-600-Datei und sonst nirgends — es taucht nie in der Unit-Datei auf, nicht in systemctl show, in keinem argv. Ein Armer-Leute-Secrets-Manager, gebaut aus systemd und bash, und er funktioniert.

Weitere Stolperfallen aus dem echten Betrieb:

• Setze beide Auth-Variablen. Je nach CLI-Version wird ANTHROPIC_AUTH_TOKEN oder ANTHROPIC_API_KEY gelesen; nur eine zu setzen ist Glückssache.
• Pinne ANTHROPIC_MODEL, sonst werden die üblichen sonnet/opus-Aliase der CLI an DeepSeeks Endpoint geschickt und liefern 404.
• Der Drop-in überschattet jeden echten Anthropic-Schlüssel. Eine Umgebung besitzt die ganze CLI — ich habe es gemerkt, als er still meine „Route zum echten Claude"-Aliase kaputtgemacht hat.
• Erst das leere ExecStart= — die leere Zeile vor der Überschreibung —, sonst hängt systemd deinen Befehl nur an, statt den ursprünglichen zu ersetzen.
• Paket-Updates können den Wrapper verwaisen lassen. Er hardcodiert den Startbefehl, also braucht ein Update, das den echten ExecStart ändert, eine neu generierte Drop-in-Datei. Mein Generator liest den kanonischen Befehl aus dem FragmentPath der Unit und weigert sich, etwas zu umwickeln, das bereits $$DEEPSEEK_API_KEY enthält.
• Dann neu laden: systemctl --user daemon-reload && systemctl --user restart <service>.

Um den ganzen Pfad end-to-end zu beweisen, lass die CLI weg und curl es direkt:

curl https://api.deepseek.com/anthropic/v1/messages \
  -H "x-api-key: $DEEPSEEK_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"deepseek-v4-pro","max_tokens":16,"messages":[{"role":"user","content":"ping"}]}'

Kommt eine "type":"message"-Antwort zurück, funktioniert der komplette Anthropic-kompatible Pfad wirklich.

Muster 3: wann tatsächlich DeepSeek vs. lokal

Beides zu haben heißt nicht, dass jeder Job in die Cloud geht. Pro Million Token, mit Claudes Listenpreisen zum Vergleich (Opus $5/$25, Sonnet $3/$15, Haiku $1/$5):

Option	Input	Output	Anmerkungen
DeepSeek flash	$0.14	$0.28	Cache-Read $0.0028 — Chat-Agenten-Aufgaben kosten wenige Cent am Tag
DeepSeek pro	$0.435	$0.87	die „denkende" Stufe, trotzdem 7–17× günstiger als Sonnet
Lokal (gleiche Maschine)	$0	$0	nur Stromkosten

Die größere Überraschung war die Geschwindigkeit. Lokale 100B-Klasse-Modelle zwangen mich, Turn-Timeouts auf 20–30 Minuten hochzusetzen, und zwei Agenten, die sich eine GPU-Kiste teilen, blockieren sich gegenseitig. DeepSeek antwortet in Sekunden; die 450-Sekunden-Obergrenze war nur je bei Worst-Case-Reasoning-Läufen relevant. Kontext ist die andere Lücke — ein 1M-Token-Fenster gegen grob 128k bei den lokalen Modellen —, weshalb lange Agenten-Sitzungen und Coding-Jobs an großen Codebasen standardmäßig zu DeepSeek gehen. Bildverarbeitung geht in die Gegenrichtung: Meine DeepSeek-Einträge sind textbasiert, also bleibt „schau dir dieses Bild an" auf einem lokalen Vision-Modell.

Die Datenschutz-Faustregel, die ich tatsächlich befolge: Schick der Cloud nichts, was du nicht auch in eine E-Mail schreiben würdest.

Fallback-Ketten wirken in beide Richtungen, und das ist mein Lieblingsteil. Cloud-primäre Agenten fallen auf ein lokales Modell zurück, wenn Internet oder API sterben; das lokal-primäre Arbeitspferd fällt auf DeepSeek flash zurück, wenn der lokale Server beschäftigt oder tot ist. Niemand geht komplett dunkel.

Stolperfallen, die Kurzfassung

Das reasoning: true-Flag, das 120-Sekunden-Timeout, das $$-Escape und der Drop-in, der deinen echten Anthropic-Schlüssel überschattet, sind alle schon in Muster 1 und 2 behandelt. Noch zwei mehr:

• Eine nicht-leere Plugin-Allowlist ist strikt. In OpenClaw wird ein aktivierter Provider-Eintrag, der in plugins.allow fehlt, nie geladen. Kein Fehler, keine Warnung, nur Stille.
• DeepSeek ist hier textbasiert. Prüfe "input" im Modelleintrag, bevor du Bildjobs dorthin routest.

Willst du es stattdessen komplett lokal — ohne API-Schlüssel, ohne Cloud-Rechnung? Das habe ich auch aufgeschrieben: DeepSeek: Lokal ausgeführt — eine 4-Schritte-Anleitung. Dort laufen DeepSeek-Destillate auf deiner eigenen GPU mit Ollama, Docker und Open WebUI. Das ist der Anfängerweg; dieser hier ist für den Moment, in dem die harten Jobs deiner GPU entwachsen, das Private aber trotzdem zuhause bleiben soll.