Cómo usar Claude Code con cualquier LLM

Hace unos días me encontré con un problema que me tiene harto. Llevo meses usando Claude Code, pero nunca me alcanzó. Partí con la suscripción Max de $100 al mes, luego salté a la de $200 — la más cara que existe — y ni así. O se me acaba la cuota a mitad de mes, o los servidores de Anthropic están caídos, o noto que las respuestas cada vez son más genéricas. Como si al saturarse la plataforma, el modelo se estuviera volviendo más tonto.

Y ahí me di cuenta de algo: estoy pagando $200 al mes (la suscripción más cara que existe) por un servicio que me falla más de lo que funciona.

Por eso empecé a buscar alternativas. Y lo que encontré me cambió la forma en que trabajo con IA.

🤖 Claude Code: tu empleado de IA, ahora con manos

Saca a Claude del chat a tu computador: te ordena archivos, cuadra gastos, arma el reporte del lunes y prospecta. Sin escribir una línea de código.

Ver el curso

Acá doy por hecho que ya la usas. Si llegaste sin tener del todo claro qué es Claude Code y cómo se usa sin programar, parte por esa guía y vuelve.

Pero acá viene la parte que casi nadie sabe: Claude Code no es un modelo. Es una interfaz. Y esa interfaz se puede conectar a casi cualquier proveedor de LLM que exista.

No te estoy hablando de hackear nada ni de hacer algo ilegal. Te estoy hablando de una funcionalidad que el propio Claude Code soporta: cambiar el ANTHROPIC_BASE_URL para apuntar a otro proveedor con endpoint compatible. Y cuando hice eso, descubrí algo que me voló la cabeza.

Lo que nadie te dice sobre Claude Code

Claude Code es una CLI (command-line interface). Envía requests a una API que sigue el formato de Anthropic. Pero ese formato no es exclusivo de Anthropic.

Proveedores como Z.ai (GLM), Xiaomi (MiMo), Moonshot (Kimi), DeepSeek, y muchos otros exponen endpoints que son Anthropic-compatibles. Claude Code envía un request, el proveedor responde, y todo funciona como si nada hubiera cambiado.

En la práctica: clonas una carpeta de configuración, pegas tu API key, y claude arranca usando un modelo que cuesta $6/mes en vez de $200.

¿Suena demasiado bueno? Yo también lo pensé. Por eso hice dos cosas:

Monté un repositorio con workspaces listos — 20+ proveedores configurados, cada uno con su settings.json, instrucciones y troubleshooting. MIT license, úsalo como quieras.
Corrí más de 9.000 benchmarks con 83 modelos — 91 tests por modelo, 26 suites de evaluación, juez Phi-4 local (Microsoft, 14B, sin conflicto de interés). No tomé la palabra del marketing de ninguno. Medí.

Los resultados me sorprendieron. Y creo que a ti también te van a sorprender.

Ningún modelo gana en todo (por eso el router)

Antes de la práctica, mira esto. Si no, vas a pensar que te vendo humo.

Corrí el benchmark sobre 83 modelos con cobertura real —130 catalogados—, más de 9.000 tests por ronda, con un juez local sin interés comercial. El primer hallazgo rompe la intuición: pagar más no compra calidad. La correlación entre costo y calidad da +0,05: estadísticamente, nula. El modelo caro no rinde peor; rinde parejo, pero cuesta y tarda más. Cuando el costo entra en la ecuación, los abiertos baratos se llevan el top: Devstral Small lidera el ranking general con 8,37, y Claude Opus 4.8 aparece recién en el puesto 17.

Pero acá está lo que de verdad importa si usas Claude Code para todo, como yo: no existe un único mejor modelo. Cada tarea tiene su líder.

Para esto…	Líder hoy (junio 2026)
Generar código	Devstral Small · Llama 4 Scout
Agente multi-turno (lo que más hace Claude Code)	GPT-OSS 120B
Tool-calling: leer archivos, ejecutar comandos	Llama 3.1 8B Instant
Visión + código	Kimi K2.7 (mi experiencia, ver abajo)

Por eso el router de la vía 4 tiene sentido: una tarea de fondo no necesita el mismo modelo que un refactor pesado. Y hay un hallazgo que vale oro para quien vive en sesiones largas: forzar el modo «thinking» empeora el trabajo multi-turno en 8 de 9 modelos que lo probé. El razonamiento extra que cobran los premium no te ayuda en una sesión de agente larga; te la encarece.

No te voy a dar «el mejor modelo». Te doy los datos. Están abiertos en github.com/ctala/ai-benchmarks-alternativos y en benchmarks.cristiantala.com. Pruébalos con tu propio trabajo y valida los resultados por tu cuenta. No me creas a mí: mira el número.

El mismo modelo, distinto proveedor: importa más de lo que crees

Otro hallazgo que me hizo repensar todo: el provider importa tanto como el modelo.

Gemma 4 31B corrió en tres proveedores distintos:

Provider	Score	Costo	tok/s
NVIDIA NIM	7.20	$0.00	22.8
OpenRouter	7.20	$0.99	22.8
DGX Spark local (Q4)	6.84	$0.00	9.3

NIM gratis da exactamente el mismo resultado que OpenRouter pagado. Y Kimi K2.5 en NIM gratis empata al 100% con OpenRouter a $1.26/1k calls. Pagar por ese modelo cuando NIM lo da gratis es, literalmente, quemar dinero.

La regla es simple: si Groq tiene el modelo, usa Groq. Su LPU entrega 5-10× más velocidad a precio competitivo. Si quieres costo cero con calidad FP16, usa NIM (con límite de 40 RPM, pero gratis).

Las 4 vías para conectar Claude Code a otro modelo

Acá viene la parte práctica. Hay cuatro formas de hacerlo, de la más fácil a la de más control. La mayoría empieza por la 1 y termina en la 4 cuando el flujo se pone serio. No necesitas las cuatro: necesitas la que calza con cómo trabajas. Todo lo que sigue está documentado con archivos de configuración listos en github.com/ctala/claude-code-providers.

Vía 1 — `ollama launch`: lo más rápido (5 minutos)

Ollama agregó un comando que hace todo el trabajo sucio: ollama launch. Levanta Claude Code ya apuntado a un modelo de Ollama, sin que toques una sola variable de entorno.

## Instala Ollama si no lo tienes
curl -fsSL https://ollama.com/install.sh | sh

## Lanza Claude Code con un modelo en la nube de Ollama
ollama launch claude --model qwen3.5:cloud

El sufijo :cloud corre el modelo en la infraestructura de Ollama, no en tu máquina. No necesitas GPU. Para correr uno local, quita el :cloud y se descarga la primera vez.

Por debajo, ollama launch setea ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN y ANTHROPIC_API_KEY, y arranca claude. Es la forma más limpia de probar si esto te sirve antes de invertir más tiempo. Si quieres ver qué hace por dentro, el equivalente manual es:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3.5

Un detalle que importa: Claude Code necesita modelos con ventana de contexto de 64.000 tokens o más para repos reales. Si eliges uno corto, se queda sin espacio a la mitad de una tarea.

Vía 2 — `settings.json` por proyecto: un modelo fijo para una carpeta

Esta es la que más uso. Cuando un proyecto siempre va a correr con el mismo modelo, no quieres estar eligiéndolo cada vez. Lo fijas en la carpeta y se acabó.

Claude Code lee un archivo .claude/settings.json dentro de cada proyecto. Ahí pones el proveedor y el modelo, y cada vez que abres claude en esa carpeta arranca con ese modelo. Otra carpeta, otro modelo, sin pisarse.

Ejemplo real: tengo un proyecto que corre siempre con MiniMax. Su .claude/settings.json es esto:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.minimax.io/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "TU_API_KEY_DE_MINIMAX",
    "API_TIMEOUT_MS": "3000000",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "ANTHROPIC_MODEL": "MiniMax-M2.7-highspeed",
    "ANTHROPIC_SMALL_FAST_MODEL": "MiniMax-M2.7-highspeed",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "MiniMax-M2.7-highspeed",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "MiniMax-M2.7-highspeed",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "MiniMax-M2.7-highspeed"
  }
}

Lo que importa de esa config:

Las cinco variables ANTHROPIC_*_MODEL son las que más gente olvida, y por eso le falla. Claude Code usa por dentro varios tiers (sonnet, opus, haiku); si no le dices cuál usar en cada uno, intenta llamar al modelo de Anthropic correspondiente y recibes errores 404 silenciosos. Apúntalas todas al mismo modelo.
La key va en ANTHROPIC_AUTH_TOKEN, no en ANTHROPIC_API_KEY, porque es un proveedor de terceros. Más abajo explico por qué confundirlas te tira un 401.
API_TIMEOUT_MS: 3000000 son 50 minutos, para que no corte una tarea larga.
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: 1 apaga unas llamadas internas que varios proveedores no soportan. Si las dejas, la sesión se cuelga.

Un cuidado de seguridad: si la key va en settings.json y commiteas la carpeta, la subes a GitHub. Usa .claude/settings.local.json (gitignored) para la key real y deja settings.json con la config compartible. Tengo 20+ proveedores ya armados así en el repositorio: clonas, pegas tu key, listo.

Vía 3 — Variable global: cambiar el default de toda la máquina

Si quieres que todo Claude Code, en cualquier carpeta, use otro proveedor por defecto, pones las variables en tu shell (~/.zshrc o ~/.bashrc):

export ANTHROPIC_BASE_URL="https://api.minimax.io/anthropic"
export ANTHROPIC_AUTH_TOKEN="TU_API_KEY"

Funciona, pero ojo: la variable del shell le gana a la config por proyecto. Si un día Claude Code se comporta raro en una carpeta, lo primero que reviso es esto:

env | grep ANTHROPIC

Si ves algo ahí que no pusiste a propósito, esa variable está sobrescribiendo todo lo demás. Para volver a Anthropic directo, un unset y listo:

unset ANTHROPIC_BASE_URL ANTHROPIC_AUTH_TOKEN ANTHROPIC_API_KEY

Por eso prefiero la vía 2: el control por carpeta no te sorprende.

Vía 4 — Claude Code Router: un modelo distinto para cada tipo de tarea

Las tres vías de arriba apuntan Claude Code a un solo proveedor. La cuarta resuelve algo que las otras no: no todas las tareas necesitan el mismo modelo.

Resumir un archivo no necesita el modelo más caro. Razonar una arquitectura sí. Pagar el premium para las dos es quemar dinero.

Claude Code Router (CCR) corre en tu máquina y se hace pasar por Anthropic. Claude Code le habla a él; él decide a qué proveedor manda cada request según el tipo de tarea.

npm install -g @musistudio/claude-code-router   ## o: brew install claude-code-router
ccr start      ## levanta el router
ccr code       ## abre Claude Code a través del router

Todo vive en ~/.claude-code-router/config.json: declaras tus proveedores una vez y asignas un modelo a cada “slot” de tarea. Esta es la parte de mi config real que hace el ruteo:

"Router": {
  "default":     "minimax,MiniMax-M3",
  "background":  "ollama-cloud,glm-4.7-flash",
  "think":       "ollama-cloud,kimi-k2.7-code:cloud",
  "longContext": "ollama-cloud,glm-5.2:cloud",
  "longContextThreshold": 60000
}

Qué hace cada slot:

Slot	Cuándo se activa	Por qué
`default`	conversación normal	el modelo que eliges de base
`background`	tareas de fondo (resúmenes, leer archivos)	barato y rápido
`think`	razonamiento profundo	el más capaz
`longContext`	sobre 60.000 tokens de contexto	uno que aguante contextos grandes

Arranco ccr code y no hago nada más. Las tareas de fondo se van a un modelo barato, el razonamiento pesado a uno fuerte, y yo no toco un botón. Cada proveedor se declara una sola vez con su URL y su key: si la API es estilo Anthropic (MiniMax, Ollama Cloud) le agregas un transformer "Anthropic"; si es estilo OpenAI (NVIDIA NIM, por ejemplo) lo dejas sin transformer. ccr ui abre un panel web para editar todo sin tocar el JSON a mano.

El detalle del longContext que casi nadie te cuenta. Ese longContextThreshold: 60000 no limita tu contexto: solo decide a partir de qué tamaño de request el router cambia al modelo del slot longContext. Lo que de verdad importa es la ventana de ese modelo. En mis sesiones de trabajo real paso los 300.000 tokens. Si el modelo del slot aguanta 256.000 (como Kimi K2.7), se queda corto justo cuando más lo necesito. Por eso ahí pongo GLM-5.2, que llega a 976.000, casi un millón; MiniMax-M3 también sirve, con 512.000 en la nube. El umbral lo dejas bajo para que cambie temprano; el modelo del slot es el que no puede ser chico.

Los nombres de modelos cambian cada par de semanas. Antes de copiar los míos, mira el catálogo vivo en ollama.com/search y cruza con el benchmark de más abajo para elegir el que te sirve.

¿Cuál vía elegir? Empiezas por la 1 para probar. Pasas a la 2 cuando tienes un proyecto que siempre usa el mismo modelo. Llegas a la 4 cuando el flujo se pone serio y quieres exprimir costo sin perder calidad.

Proveedores por categoría — cuál elegir según tu situación

Plan mensual: alternativas fijas a Anthropic Max

Carpeta	Proveedor	Modelos	USD/mes
`xiaomi/`	Xiaomi MiMo Token Plan	MiMo V2.5, V2.5-Pro, V2-Omni	$6-$88
`zai-coding/`	Z.ai GLM Coding Plan	GLM-4.7, GLM-5.1, GLM-4.5-Air	~$10-$80
`minimax/`	MiniMax Coding Plan	M2.7, M2.7-highspeed	$19-$50
`qwen-coding/`	Alibaba Qwen Coding Plan	Qwen3-Coder-Plus, Qwen3-Max	Variable

Mi recomendación personal: Xiaomi MiMo (plan Standard, ~$14/mes). En el benchmark rinde por encima de su precio: coding y contenido sólidos por una fracción de lo que cuesta un premium.

Pay-as-you-go: para cuando no quieres suscripción

Carpeta	Proveedor	Modelos	Notas
`deepseek/`	DeepSeek	DeepSeek-V3, Coder	De los más baratos del mercado
`openrouter/`	OpenRouter	300+ modelos	Una key para todo, fallback automático
`moonshot/`	Moonshot Kimi	Kimi K2 Turbo	Endpoint Anthropic-compat oficial
`zai-api/`	Z.ai BigModel API	GLM-4.7, GLM-5.1	Pay-per-token

OpenRouter es el comodín: una sola API key te da acceso a Anthropic, xAI, Google, Meta, Qwen, DeepSeek — 300+ modelos. Si quieres flexibilidad sin compromisos, es la opción.

Cloud enterprise: AWS, GCP, Azure

Carpeta	Plataforma	Variables
`aws-bedrock/`	AWS	`CLAUDE_CODE_USE_BEDROCK=1`
`google-vertex/`	GCP	`CLAUDE_CODE_USE_VERTEX=1`
`azure-foundry/`	Azure	Endpoint Anthropic-compat

Si tu empresa ya tiene cuentas en AWS/GCP/Azure, esto te permite consumir Claude (Bedrock, Vertex) o modelos third-party (Foundry) bajo tu IAM y facturación corporativa. Sin APIs sueltas, sin credenciales fuera del ecosistema.

El piso local: lo que corro en el DGX Spark (24/7, $0, privado)

El tercer piso de mi stack es local. Tengo un DGX Spark —GB10, memoria unificada— corriendo modelos todo el día, sin pagar por token y sin que un solo dato salga de mi red. Lo uso de dos formas:

Ollama, para modelos on-demand. Acá viven los grandes que llamo cuando los necesito: qwen3-coder-next para código, nemotron-3-super:120b, qwen2.5:72b, gemma4:31b. Y phi4, que es el juez del benchmark de arriba: corre local, sin interés comercial, por eso confío en sus notas.
llama.cpp, para modelos andando siempre. Lo que tiene que estar listo al instante no espera a que Ollama cargue: tengo llama-server sirviendo Qwen3.6 (27B y 35B) las 24 horas, con proyector multimodal —ven imágenes—. Esos no se apagan, y los unifico bajo una sola URL con un gateway LiteLLM.

Apuntar Claude Code a cualquiera de ellos es lo mismo que ya viste: ANTHROPIC_BASE_URL a la dirección del Spark, o un slot del router que mande las tareas privadas ahí. Costo por token: cero. Privacidad: total. El único costo es la electricidad y el fierro, que ya lo tienes.

Y esos modelos no solo alimentan a Claude Code: también mueven mis propios agentes, que corren todo el día sobre ellos sin depender de la nube de nadie.

No necesitas un Spark para esto. Una GPU de 24GB+, un Mac con Apple Silicon o LM Studio sobre una máquina decente ya te corren modelos locales útiles. El Spark solo me deja correr los de 120B sin pestañear.

La trampa de ANTHROPIC_AUTH_TOKEN vs ANTHROPIC_API_KEY

Un error que me quitó 2 horas la primera vez — y por eso lo puse en el docs/troubleshooting.md del repo:

ANTHROPIC_AUTH_TOKEN — Para proveedores third-party con endpoint Anthropic-compat (Z.ai, Xiaomi, Moonshot, DeepSeek).
ANTHROPIC_API_KEY — Solo para Anthropic directo (pay-as-you-go en api.anthropic.com).

Confundirlas = error 401 inmediato. Y no es obvio hasta que lees la documentación del proveedor.

Otros dos errores que te van a pasar la primera vez:

HTTP 400 al arrancar. Claude Code manda unos headers «beta» que varios proveedores no reconocen. Lo apagas con "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1" en tu settings.json.
404 silencioso de modelo. Si no apuntas las cinco variables ANTHROPIC_*_MODEL al modelo de tu proveedor, Claude Code intenta llamar a un modelo de Anthropic que tu key no tiene. Por eso la vía 2 las setea todas.

¿Pero funcionan de verdad estos modelos para coding?

La pregunta del millón. Si vas a usar Claude Code, es para programar. Probé 23 suites distintas, incluyendo code_generation, tool_calling, y structured_output.

Los resultados por suite:

Suite	Mejor modelo	Score
Code generation	Llama 4 Scout 17B	8.04
Tool calling	Llama 3.1 8B Instant	8.45
Structured output	Llama 3.1 8B Instant	8.00
String precision	Devstral Small	8.12
Razonamiento	GPT-OSS 20B	7.97
Deep reasoning	Llama 4 Scout 17B	7.68

Devstral Small (Mistral, Apache 2.0, $0.10/$0.30 per M tokens) es la sorpresa del benchmark — open-source, barato, y domina coding con un tool calling excelente.

Ahora, una advertencia honesta: el benchmark mide modelos solos, single-turn, sin herramientas. En producción real, un workflow N8N con herramientas (búsqueda web, RAG, API calls) puede invertir el ranking. Qwen 3.5 397B, por ejemplo, parece «regular» en el benchmark (score global 6.72) pero en producción genera artículos excelentes para ecosistemastartup.com porque se integra perfecto con tools de búsqueda.

El benchmark te da la línea base. Tu workflow real te da el resultado.

Mi stack real (junio 2026) y por qué

No uso Claude Code solo para programar. Lo uso como sistema operativo de todo mi trabajo: código, contenido, investigación, operar el negocio. Eso cambia qué modelo me sirve. No me alcanza con que sea bueno en código: también tiene que sostener agentes largos y, cada vez más, leer imágenes.

Hoy mi stack son cuatro suscripciones de modelos, casi $310 al mes:

Anthropic Max ($200/mes). Para lo crítico. Cuando necesito Opus de verdad, lo tengo. No para todo: para lo que lo amerita.
MiniMax ($50/mes). Buen código, pero solo texto: no ve imágenes.
Kimi ($39/mes). La acabo de sumar. Me rinde parejo a MiniMax en código y además procesa imágenes.
Ollama Cloud ($20/mes). Modelos abiertos en la nube (:cloud) sin montar una GPU: mi banco de pruebas y la opción barata para las tareas de fondo del router.

¿Por qué pago MiniMax y Kimi a la vez? Porque sumé Kimi por una razón concreta —la visión— y ahora estoy evaluando si suelto MiniMax. Para un sistema operativo de trabajo, donde paso capturas y diagramas todo el día, que el modelo no vea imágenes es un techo.

Un caveat honesto: mi propio benchmark todavía no mide K2.7. Llega hasta K2.6, y la variante «thinking» de esa rindió por debajo —coherente con lo del thinking forzado—. Así que esto no es una recomendación de score: es mi experiencia de uso más una capacidad que MiniMax no tiene. Cuando K2.7 entre al benchmark, lo actualizo con número.

La regla no cambió: arranco con lo barato por defecto, y subo al modelo caro solo cuando la tarea lo pide. Con el router, eso pasa solo.

Lo que aprendí haciendo esto

Correr más de 9.000 benchmarks con 83 modelos no es gratis. Invertí:

~$350-400 USD en APIs (OpenAI, OpenRouter, MiniMax, Anthropic, Xiaomi)
meses de varias suscripciones en paralelo —las mismas del stack de arriba— para tener acceso a todos los proveedores
~190h de cómputo cloud
~50h de cómputo local (DGX Spark + GPU en Mac M-series)
meses de trabajo humano —muchas más horas de las que quiero sumar— en diseño de tests, debugging, análisis y documentación

Todo eso está disponible gratis bajo MIT license en los dos repositorios. Si te ahorró una tarde de debugging de Anthropic Base URL, dale una estrella — ayuda a que otros devs lo encuentren.

github.com/ctala/claude-code-providers — workspaces listos para 20+ proveedores
github.com/ctala/ai-benchmarks-alternativos — 9.000+ benchmarks, 83 modelos, 26 suites
benchmarks.cristiantala.com — dashboard interactivo para explorar y comparar los resultados

La verdad incómoda

No existe el «mejor modelo». Y quien te diga que sí, probablemente te está vendiendo uno.

Lo que existe es el mejor modelo para lo que necesitas, con el presupuesto que tienes, en el contexto que trabajas.

¿Coding rápido y barato? Devstral Small o DeepSeek V3.
¿Agentes 24/7 con costo predecible? MiniMax M2.7 a $19/mes fijo.
¿Contenido SEO en español? DeepSeek V3.2 es #1 en news_seo_writing.
¿Soporte al cliente donde la honestidad importa? Claude Sonnet — no inventa respuestas.
¿Privacidad total? Ollama local con los modelos que ya corren en tu hardware.
¿Flexibilidad absoluta? OpenRouter con una key para 300+ modelos.

El ecosistema de LLMs en 2026 es un banquete — y la mayoría sigue comiendo en el mismo restaurante caro. Hay alternativas mejores, más baratas, y en muchos casos, abiertas.

La pregunta no es «cuál es el mejor modelo». La pregunta es: ¿qué quieres construir hoy, y cuánto quieres pagar por las herramientas?

¿Tienes dudas sobre qué modelo usar para tu caso específico? Únete a mi comunidad de emprendedores en Cágala, Aprende, Repite — ahí podemos ayudarte entre todos. Y si quieres ver cómo armo los benchmarks con N8N y OpenClaw en la práctica, el workflow está documentado en el repo.

📊 Benchmark relacionado: Comparé 89 modelos con 9,628 tests reales — ver el análisis completo. Si quieres el comparativo original (27 tests, 8 modelos), está acá.