DeepSeek en Todas Partes: Cableando un Cerebro Barato en la Nube a Claude Code y a un Stack de Agentes Local

DeepSeek ahora sostiene tres cosas distintas en mi casa: el cerebro de mi stack de agentes, la CLI de Claude Code, y el peldaño en la nube de una escalera de fallback. El esfuerzo total de cableado fue algo de JSON, unas cuantas variables de entorno, y un bug de escapado de systemd que se comió una noche entera.

Lo que obtienes

Antes del cómo, la forma del asunto. Yo tengo OpenClaw, un gateway de agentes, con ocho agentes con nombre detrás de una interfaz de chat, más la CLI de Claude Code que esos agentes lanzan para el trabajo de codificación real. DeepSeek respalda a ambos.

Patrón	Qué hace	Coste
1. Cerebro del agente	DeepSeek como proveedor en la configuración del gateway; cualquier agente puede elegirlo como principal o como fallback	$0,14–$0,87 / millón de tokens
2. Backend de Claude Code	Un drop-in de systemd redirige la CLI al endpoint compatible con Anthropic de DeepSeek, sin reinstalar	mismo precio por token
3. Escalera de fallback	Una lista de decisión sobre cuándo un trabajo va a DeepSeek frente a un modelo local	$0 cuando se queda en local

La línea que hace posible todo esto: DeepSeek ofrece un endpoint compatible con Anthropic en https://api.deepseek.com/anthropic. Cualquier cosa construida para hablar con Claude — la CLI de Claude Code incluida — puede apuntarse a él con nada más que variables de entorno. Sin script envoltorio, sin fork.

Patrón 1: DeepSeek como cerebro de agente

Un bloque de proveedor en la configuración del gateway. El real, con la clave censurada:

"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
    }
  ]
}

Cada agente elige después un modelo principal y una cadena de fallback:

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

Esto es lo que pasa cuando llega un mensaje con ese enrutado:

Mi plantilla real. La mayoría de agentes empiezan con DeepSeek y caen a local; Doxy hace justo lo contrario a propósito:

Agente	Principal	Fallbacks
Bits (chat principal)	DeepSeek flash	DeepSeek pro → local gemma-4-31b
Brains	DeepSeek pro	local gemma-4-31b
Flash	DeepSeek flash	DeepSeek pro → local
Hermes (agente de despliegue)	DeepSeek pro	DeepSeek flash → local
Alpha (seguro para toda la familia)	DeepSeek flash	DeepSeek pro → local
Doxy (caballo de batalla local)	local 120B	DeepSeek flash (al revés — local va primero)
beta	local	DeepSeek flash → DeepSeek pro
Charley (visión)	local gemma-31b	DeepSeek pro → DeepSeek flash

Aquí es donde importa Charley: estas entradas de DeepSeek son solo texto ("input": ["text"]), así que el trabajo con imágenes se queda en local pase lo que pase en la cadena. Los alias (ds-flash, ds-brain) me dejan cambiar de modelo a mitad de conversación sin tocar la configuración.

Dos ajustes te van a morder si te los saltas:

• "reasoning": true es obligatorio para los modelos de razonamiento. Transmiten reasoning_content antes de la respuesta real; con el flag apagado, el gateway solo oye silencio, decide que el modelo se ha colgado, y mata el turno sobre los 390 segundos. Pregúntame cómo lo sé.
• Sube timeoutSeconds. El timeout de petición por defecto era de 120 segundos; las ejecuciones largas de razonamiento lo superan y "fallan" al azar. 450 lo arregló aquí, y los ajustes de proveedor se recargan en caliente — sin reiniciar el gateway.

Patrón 2: la CLI de Claude Code sobre DeepSeek

La CLI de Claude Code lee ANTHROPIC_BASE_URL, ANTHROPIC_MODEL, y ANTHROPIC_AUTH_TOKEN/ANTHROPIC_API_KEY de su entorno, y el endpoint /anthropic de DeepSeek habla el mismo formato de cable que Claude. Así que redirigir la CLI es solo cambiar el entorno que el gateway le pasa a cada subproceso de Claude Code que lanza — la CLI se queda como una instalación de fábrica.

El archivo es un drop-in de usuario de systemd. El mío lo genera una pequeña app en GTK que construí que alterna entre cuatro modos (Local LM Studio / DeepSeek / Anthropic Cloud / Off), pero es lo bastante corto como para escribirlo a mano:

# ~/.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'

La clave en sí vive en un único lugar: el EnvironmentFile del servicio (~/.openclaw/gateway.systemd.env, chmod 600), que solo contiene DEEPSEEK_API_KEY=CHANGE_ME.

La trampa del $$ (la razón entera por la que existe este artículo)

Mi primer intento usó un solo $. No fue bien. Dentro de un archivo unit, $VAR lo expande el propio systemd en el momento de lanzar el proceso, lo que hornea la clave directamente en la línea de comandos — visible en ps, en /proc/<pid>/cmdline, y en systemctl show. No exactamente donde quieres que se siente un secreto.

$$VAR es el escape de systemd para un $VAR literal: systemd pasa la cadena tal cual, sin tocarla, y bash la expande en tiempo de ejecución, a partir del entorno que el EnvironmentFile ya había poblado. Efecto neto: el secreto existe en un único archivo con chmod 600 y en ningún otro sitio — nunca aparece en el archivo unit, en systemctl show, ni en ningún argv. Un gestor de secretos de andar por casa hecho con systemd y bash, y funciona.

Más trampas de usar esto en la práctica:

• Fija ambas variables de autenticación. Distintas versiones de la CLI leen ANTHROPIC_AUTH_TOKEN o ANTHROPIC_API_KEY; fijar solo una es tirar una moneda al aire.
• Fija ANTHROPIC_MODEL, o los alias habituales de sonnet/opus de la CLI se enviarán al endpoint de DeepSeek y darán 404.
• El drop-in tapa cualquier clave real de Anthropic. Un solo entorno controla toda la CLI — lo descubrí cuando rompió en silencio mis alias de "conectar al Claude real".
• Primero el ExecStart= vacío — la línea vacía antes de la sobrescritura — o systemd añadirá tu comando en lugar de reemplazar el original.
• Las actualizaciones de paquete pueden dejar huérfano el wrapper. Codifica el comando de lanzamiento a fuego, así que una actualización que cambie el ExecStart real significa regenerar el drop-in. Mi generador lee el comando canónico desde el FragmentPath de la unidad y se niega a envolver nada que ya contenga $$DEEPSEEK_API_KEY.
• Luego recarga: systemctl --user daemon-reload && systemctl --user restart <service>.

Para comprobar toda la ruta de extremo a extremo, sáltate la CLI y usa curl:

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"}]}'

Una respuesta "type":"message" significa que toda la ruta compatible con Anthropic funciona de verdad.

Patrón 3: cuándo usar DeepSeek de verdad frente a lo local

Tener ambos no significa que todo trabajo vaya a la nube. Por millón de tokens, con los precios de lista de Claude como referencia de escala (Opus $5/$25, Sonnet $3/$15, Haiku $1/$5):

Opción	Entrada	Salida	Notas
DeepSeek flash	$0,14	$0,28	lectura de caché $0,0028 — el trabajo de agente de chat cuesta céntimos al día
DeepSeek pro	$0,435	$0,87	el nivel "pensante", aun así 7–17 veces más barato que Sonnet
Local (misma máquina)	$0	$0	solo electricidad

La velocidad fue la sorpresa mayor. Los modelos locales de clase 100B me obligaron a subir los timeouts de turno a 20–30 minutos, y dos agentes compartiendo una misma máquina con GPU se atascan mutuamente. DeepSeek responde en segundos; el techo de 450 segundos solo importó de verdad en los peores casos de razonamiento. El contexto es la otra brecha — una ventana de 1M de tokens frente a unos 128k en los modelos locales — así que las sesiones de agente largas y los trabajos de codificación en bases de código grandes van por defecto a DeepSeek. La visión va en dirección contraria: mis entradas de DeepSeek son solo texto, así que "mira esta imagen" se queda en un modelo de visión local.

La regla de privacidad que uso de verdad: no le mandes a la nube nada que no pondrías en un correo electrónico.

Las cadenas de fallback cortan en ambos sentidos, que es mi parte favorita. Los agentes con la nube como principal bajan a un modelo local cuando internet o la API mueren; el caballo de batalla con lo local como principal recurre a DeepSeek flash cuando el servidor local está ocupado o caído. Nadie se queda completamente a oscuras.

Trampas, la lista corta

El flag reasoning: true, el timeout de 120 segundos, el escape $$, y el drop-in tapando tu clave real de Anthropic ya están cubiertos en los Patrones 1 y 2. Dos más:

• Una allowlist de plugins no vacía es estricta. En OpenClaw, una entrada de proveedor habilitada que falte en plugins.allow nunca se carga. Sin error, sin aviso, solo silencio.
• Aquí DeepSeek es solo texto. Comprueba "input" en la entrada del modelo antes de enrutarle trabajos de visión.

¿Prefieres que sea totalmente local — sin clave de API, sin factura en la nube? También lo escribí: DeepSeek: ejecutándolo en local — una guía de 4 pasos, con destilados de DeepSeek en tu propia GPU usando Ollama, Docker, y Open WebUI. Ese es el camino para principiantes; este es para cuando los trabajos difíciles superan tu GPU pero lo privado sigue quedándose en casa.