Monta tu propio router de modelos con Rebel Router

Laboratorio · IA local

30 min nivel medio configuración validada

1. Claude Code · paso 5 ANTHROPIC_BASE_URL
2. OpenCode · paso 6 proveedor rebel
3. Rebel Router · paso 4 127.0.0.1:8787
4. Presupuestos · paso 3 rebel.yaml
5. Proveedores · paso 2 tus claves (.env)
6. OpenCode Zen · paso 2 una clave, varios
7. Registro FinOps · paso 4 SQLite + panel

Instala Rebel Router desde GitLab, conéctalo a Claude Code y OpenCode, fija presupuestos y comprueba qué modelo responde y cuánto cuesta.

Qué vas a montar y por qué

Claude Code y OpenCode mandan casi todo al mismo modelo: el que elegiste al abrir la sesión. Eso incluye escribir un test, resumir un fichero o actualizar un README, tareas que un modelo mucho más barato resuelve igual de bien. Rebel Router es un proxy local que se pone en medio: mira cada petición, decide de qué tipo es (orquestación, código complejo, código masivo, tests unitarios, QA o documentación), elige entre los tres modelos que mejor encajan por calidad, precio y velocidad, y apunta el coste en un registro SQLite con presupuestos.

En este laboratorio lo instalas desde su repositorio en GitLab, pones tus propias claves (o una sola de OpenCode Zen), lo conectas a Claude Code y a OpenCode, fijas un presupuesto diario y por proyecto, y compruebas qué modelo ha contestado de verdad y cuánto ha costado. Todo corre en tu máquina; el router solo escucha en 127.0.0.1.

Un aviso antes de empezar: en nuestro benchmark de 12 tareas, dejar que el router eligiera costó un 82% menos que usar Claude Opus 5.5 para todo, pero acertó 9 de 12 tareas frente a 11 de 12. Es una primera medición con una muestra pequeña. Por eso el laboratorio te enseña también a mantener en Opus lo que no quieras arriesgar.

Requisitos

SistemamacOS o Linux (Windows con WSL)

Node.js22.13

Rebel Router0.1.0

Claude Code2.1.295

OpenCode1.19.0

RAM512 MB libres

Disco300 MB

Paso a paso

1. Clona e instala Rebel Router

   Necesitas Node.js 22.13 o superior. El paquete tiene una sola dependencia de ejecución. npm install compila el código y npm link deja el comando rebel en tu PATH.

   Si npm link pide permisos, es que tu prefijo global de npm es del sistema. Usa un gestor de versiones de Node o lanza el router desde el clon con npx rebel start.

   $ git clone https://gitlab.com/larebelion/rebel-router.git
   $ cd rebel-router
   $ npm install
   $ npm link
   $ rebel models

2. Pon tus propias claves (o una de OpenCode Zen)

   Rebel Router no trae claves: usa las tuyas, y solo para el proveedor que elige en cada petición. Copia el ejemplo a .env y rellena las que tengas. Un proveedor sin clave se ignora.

   Si no quieres una clave por proveedor, una clave de OpenCode Zen en OPENCODE_API_KEY da acceso a GPT, Grok, DeepSeek, Kimi, GLM y Qwen. Por defecto Zen solo se usa para los proveedores que no tienen clave propia y nunca para Claude. Gemini no está en Zen y sigue necesitando GEMINI_API_KEY. VENICE_API_KEY es opcional: activa el clasificador JEV (en beta); sin ella el router clasifica con reglas locales.

   $ cp .env.example .env
   $ chmod 600 .env

   Fichero .env

   ANTHROPIC_API_KEY=CHANGE_ME_ANTHROPIC_API_KEY
   OPENAI_API_KEY=
   XAI_API_KEY=
   GEMINI_API_KEY=CHANGE_ME_GEMINI_API_KEY
   DEEPSEEK_API_KEY=
   OPENCODE_API_KEY=CHANGE_ME_OPENCODE_ZEN_KEY
   VENICE_API_KEY=

   Sustituye cada valor CHANGE_ME_… por uno tuyo antes de arrancar: no dejes contraseñas ni claves de ejemplo.

3. Fija presupuestos y reglas

   La configuración vive en ~/.rebel-router/rebel.yaml (o en ./rebel.yaml del directorio donde arrancas el router). Este fichero pone un tope de 10 dólares al día, 3 para el proyecto shop, y a partir del 80% de un presupuesto prefiere modelos más baratos; al llegar al 100% baja al modelo aceptable más barato (downgrade) en vez de cortar.

   Dos reglas que conviene conocer desde el primer día: aliases.opus: passthrough hace que lo que pidas a Opus llegue a Opus sin cambios, y localOnly obliga a que un proyecto no salga de tu máquina (solo modelos de Ollama). Si prefieres que el router corte en seco, cambia onLimit a block y responderá HTTP 402.

   $ mkdir -p ~/.rebel-router

   Fichero ~/.rebel-router/rebel.yaml

   server:
     host: 127.0.0.1
     port: 8787
   routing:
     excludeProviders: []
     aliases:
       opus: passthrough
       haiku: hint
   budgets:
     daily: 10
     projects:
       shop: 3
     onLimit: downgrade
     downgradeAt: 0.8
   projects:
     secret-client:
       localOnly: true
   opencode:
     gateway: auto

4. Arranca el router

   Carga el .env en el entorno y arranca. El router escucha en http://127.0.0.1:8787, sirve el panel en /dashboard y escribe cada petición en ~/.rebel-router/ledger.db. Déjalo en un terminal propio o como servicio de tu sistema.

   La línea providers del arranque dice qué proveedores tienen clave y cuáles van por Zen. Revísala: si falta uno que esperabas, el .env no se ha cargado.

   $ set -a; . ./.env; set +a
   $ rebel start

   Salida esperada

   Rebel Router 0.1.0 listening on http://127.0.0.1:8787
     classifier: local rules (set VENICE_API_KEY to enable JEV)
     dashboard:  http://127.0.0.1:8787/dashboard
     Claude Code: ANTHROPIC_BASE_URL=http://127.0.0.1:8787   OpenCode: baseURL http://127.0.0.1:8787/v1

5. Conecta Claude Code

   rebel init claude --global mezcla la configuración en ~/.claude/settings.json (hace antes una copia settings.json.rebel-backup y no toca nada más). Pone ANTHROPIC_BASE_URL apuntando al router, activa las cabeceras que dicen si una llamada es de la sesión principal, de un subagente o de una compactación, y añade los hooks, la línea de estado y los comandos /rebel-spend y /rebel-top.

   Con --global pasan por el router la CLI, claude -p, los subagentes, las extensiones de IDE y el Agent SDK con la configuración de usuario. Para presupuestos por proyecto, instala además en cada proyecto con --project: así cada petición lleva la cabecera x-rebel-project. Reinicia Claude Code después.

   Ojo con lo que verás: Claude Code sigue mostrando el modelo que pidió (por ejemplo Opus); el que respondió de verdad sale en la línea de estado. Ningún hook puede cambiar el modelo de la sesión, por eso el cambio lo hace el proxy.

   $ rebel init claude --global

   $ cd ~/code/shop
   $ rebel init claude --project shop

6. Conecta OpenCode

   En OpenCode el router se declara como un proveedor más. rebel init opencode escribe opencode.json con el proveedor rebel y un plugin en .opencode/plugins/. Después elige el modelo rebel/auto con /models, o rebel/auto:unit_tests para fijar la clase de tarea.

   La integración está hecha para OpenCode 1.19, la versión estable. Las versiones preliminares 2.0 cambiaron el formato de plugins y no cargaron el proveedor.

   $ cd ~/code/shop
   $ rebel init opencode --project shop

7. Los dos casos que se configuran a mano

   App de escritorio de Claude (pestaña Code). No lee ANTHROPIC_BASE_URL de los ficheros de configuración. Ve a Developer → Configure Third-Party Inference y pon como URL base http://127.0.0.1:8787.

   Extensión de VS Code. El Claude Code que lanza sí lee los ficheros de configuración, pero la comprobación de inicio de sesión de la extensión no. Añade la variable en la configuración de usuario de VS Code.

   Fichero settings.json (usuario de VS Code)

   {
     "claudeCode.environmentVariables": [
       { "name": "ANTHROPIC_BASE_URL", "value": "http://127.0.0.1:8787" }
     ]
   }

Comprueba que funciona

1. Mira cómo clasifica y qué elegiría

   rebel classify te enseña la clase y la complejidad que asigna a una instrucción, sin llamar a ningún modelo. rebel top lista los tres modelos que el Broker elegiría para esa clase, con el motivo. Puedes forzar una clase escribiendo #rebel:tests, #rebel:docs o #rebel:complex en el prompt.

   $ rebel classify "Escribe tests unitarios con vitest para la función slugify"
   $ rebel top --task tests

   Salida esperada

   {
     "taskClass": "unit_tests",
     "complexity": 0.15,
     "confidence": 1,
     "source": "rules",

2. Comprueba que enruta y que el gasto cuadra

   Trabaja un rato en Claude Code u OpenCode y consulta el registro. rebel spend agrupa el gasto por modelo, clase de tarea, proyecto o día; rebel export saca un CSV con cada petición (modelo pedido, modelo usado, tokens, coste, latencia y el motivo de la elección). El panel en http://127.0.0.1:8787/dashboard enseña lo mismo en gráficos.

   Para cuadrar cuentas, compara el total de un día con la consola de facturación de tu proveedor. El coste se calcula con los tokens que devuelve cada proveedor y el precio oficial del catálogo, así que debería coincidir salvo descuentos o recargos que el catálogo no conozca.

   $ rebel status
   $ rebel spend --today --by model
   $ rebel spend --today --project shop --by task_class
   $ rebel export --days 1 > gasto.csv

Si algo falla

Claude Code no pasa por el router

Comprueba que la variable está en la configuración y que el router está arrancado. Dentro de Claude Code, /status enseña la URL base que usa: un lanzador o una variable exportada en la shell puede ganar a la configuración de usuario. La app de escritorio y VS Code necesitan el paso manual del paso 7.

$ grep ANTHROPIC_BASE_URL ~/.claude/settings.json
$ rebel status

Las peticiones fallan con HTTP 402

Has llegado al presupuesto con onLimit: block. Mira qué proyecto lo ha gastado, sube el límite en rebel.yaml o cambia a downgrade para que baje de modelo en vez de cortar.

$ rebel spend --today --by project

HTTP 508 al encadenar con otro gateway

El router ha detectado un bucle: la URL de un proveedor apunta de vuelta al propio router. Si usas un gateway corporativo, pon su URL en providers.anthropic.baseUrl del rebel.yaml y deja Claude Code apuntando al router.

OpenCode dice que el modelo rebel/auto no está disponible

Suele ser una versión preliminar 2.0 de OpenCode. Vuelve a la 1.19 estable y repite el paso 6.

Endurece la instalación

Que el router siga siendo local

Deja server.host en 127.0.0.1: el router guarda tus claves y rechaza peticiones con un Host que no sea local, con un Origin de otra web o con un cuerpo que no sea JSON, para que ninguna página pueda gastar tu saldo. No lo publiques en la red.

Lo crítico, en el modelo que tú elijas

El benchmark mostró dónde falla el enrutado barato: tests unitarios y QA. Usa aliases.opus: passthrough para que lo que pidas a Opus no se toque, classModels para fijar un modelo por clase de tarea y localOnly en los proyectos cuyo código no debe salir de tu máquina.

Lo que ve JEV

Si activas JEV, a Venice solo le llega un resumen: los primeros 600 caracteres de tu última instrucción, el tamaño aproximado del contexto, los nombres de las herramientas y las extensiones de fichero. Nunca el código. Con classifier.jev.summary.maxChars: 0 no envía texto, y sin VENICE_API_KEY no se usa.

Limpieza: deshacer el laboratorio

Quita el router y vuelve a como estabas

--uninstall quita solo lo que añadió Rebel Router y repone los valores que había sustituido. Después desinstala el comando y, si no quieres conservar el historial de gasto, borra ~/.rebel-router (ahí están el registro y tu rebel.yaml). En OpenCode, quita el proveedor rebel de opencode.json.

$ rebel init claude --global --uninstall
$ npm rm -g rebel-router
$ rm -r ~/.rebel-router

Qué está verificado

• · .env: sin validador automático, revísalo a mano
• ✓ Sintaxis de ~/.rebel-router/rebel.yaml (parser YAML)
• ✓ Sintaxis de settings.json (usuario de VS Code) (parser JSON)
• ✓ Sintaxis de 12 bloque(s) de comandos (bash -n en un contenedor aislado, sin ejecutarlos)
• ✓ Versiones (4), opciones (7) y claves de configuración (28) contrastadas con 8 páginas de documentación oficial
• ✓ Instalación desde GitLab (git clone, npm install, npm link) y los 90 tests del repositorio en verde
• ✓ Router con un proveedor simulado (scripts/mock-provider.mjs): peticiones de la API de Anthropic clasificadas y enrutadas, rebel spend, rebel status, rebel export y el panel /dashboard
• ✓ Presupuesto con onLimit: block: la petición que pasa del límite recibe HTTP 402
• ✓ rebel init claude --global y --uninstall sobre un settings.json existente (se conserva lo que había) y rebel init opencode
• ✓ Claude Code 2.1.295 real (claude -p con un subagente) a través del router contra el proveedor simulado (npm run smoke:claude)
• ✓ Benchmark de 12 tareas con 10 modelos y claves reales a través de un gateway (resultados en bench/results/latest.json)
• · Con tus claves de cada proveedor, la app de escritorio y la extensión de VS Code: no ejecutado aquí, revísalo en tu equipo

Comprobaciones automáticas del 11 de octubre de 2026. Lo marcado con «·» no se ha ejecutado: revísalo en tu entorno.

Fuentes

• Rebel Router: README e instalación gitlab.com
• Rebel Router con Claude Code gitlab.com
• Rebel Router con OpenCode gitlab.com
• Configuración de ejemplo (rebel.example.yaml) gitlab.com
• Benchmark de Rebel Router gitlab.com
• OpenCode Zen opencode.ai

Opinión · Qué haría yo si fuera…

Si yo empezara hoy con Rebel Router, lo dejaría una semana en modo observador: presupuesto alto, Opus en passthrough y el registro encendido. Al final de la semana miraría qué clases de tarea se llevan el gasto y solo entonces dejaría que el router decida en documentación y código masivo, que es donde el ahorro no cuesta aciertos.

Los tests unitarios los vigilaría de cerca: es justo donde el benchmark falló.

Artículos relacionados de LaRebelión

Satya Nadella pide un 'freno de emergencia' para los modelos de IAMonta Audiobookshelf con Caddy y HTTPS en Docker ComposeOpenAI admite que revelará más incidentes de modelos que actuaron sin permiso

• OpenAI frena una campaña para extraer el razonamiento de sus modelos
• El uso malicioso de modelos de inteligencia artificial
• IA Empresas Tech Adoptan Modelos Abiertos para Ahorrar

Artículo generado mediante AI.larebelion

Kernel · Dirección de tecnología · España

«Primero mide en qué se va el dinero; luego deja que el router decida.»