> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kodus.io/llms.txt
> Use this file to discover all available pages before exploring further.
# BYOK - Trae Tu Propia Clave
> Conecta tus propias claves de proveedor y luego elige qué modelo ejecuta cada tarea. Disponible en todos los planes de Kodus.
BYOK (Bring Your Own Key) es la **forma predeterminada en que Kodus usa LLMs en todos los planes** — Community, Teams y Enterprise. Conectas tus propias cuentas de proveedor, habilitas los modelos que quieres y eliges qué modelo ejecuta cada tarea. Pagas directamente a tu proveedor, Kodus nunca aplica márgenes sobre los tokens y nunca ve tu clave en texto plano.
BYOK es gratuito en Community, incluido en Teams (\$10/desarrollador activo/mes sobre tu gasto en tokens) y una de dos opciones en Enterprise (la otra es una clave de API administrada por Kodus).
## Cómo funciona BYOK
BYOK es **primero el proveedor**: conectas un proveedor una vez, le agregas los modelos que quieres y luego enrutas esos modelos a las tareas de Kody. La pantalla `/byok` tiene tres pestañas:
Conecta proveedores con tu clave y habilita modelos en cada uno. La insignia de conteo muestra cuántos proveedores has conectado.
Elige qué modelo ejecuta cada tarea — uno predeterminado para todo, un respaldo opcional y anulaciones por agente.
Define un límite de gasto mensual opcional sobre tus modelos conectados.
**Quién puede editar esto.** La página de BYOK es **solo para Owner** — conectar, probar y eliminar claves requiere el rol **Owner**. Los demás roles (Billing Manager, Repo Admin, Contributor) no pueden acceder a `/byok`. Consulta [Roles del workspace](/es/how_to_use/workspace_roles).
## Conectar un proveedor
Ve a [app.kodus.io/byok](https://app.kodus.io/byok). En un workspace nuevo verás **Connect your first provider**.
La cuadrícula de proveedores se divide en dos:
* **Providers** — proveedores de primera clase que conectas con solo una clave de API (OpenAI, Anthropic, Google AI Studio, OpenRouter, Novita…).
* **Custom** — proveedores que apuntas a tu propio endpoint o donde ejecutas un modelo arbitrario: **OpenAI-compatible**, **Anthropic-compatible**, **Google Vertex AI** y **Amazon Bedrock**. Están marcados con una indicación de *Custom endpoint*.
Un proveedor que ya conectaste muestra **Connected · N models**.
Al elegir un proveedor se abre su formulario **Add a model**. Pega la clave de API una sola vez (se reutiliza para cada modelo que agregues a ese proveedor después) y luego elige el modelo:
* Si Kodus puede listar los modelos del proveedor, obtienes un menú desplegable.
* De lo contrario (endpoints personalizados, auto-alojados, o cuando las claves de la plataforma no están configuradas), escribe el ID exacto del modelo.
Los endpoints personalizados (OpenAI-compatible / Anthropic-compatible) también piden primero una **base URL**.
Bajo **Advanced settings**: thinking/razonamiento, temperatura, máximo de tokens de salida, máximo de tokens de entrada y máximo de solicitudes concurrentes. Los valores predeterminados son razonables para la mayoría de los proveedores — consulta [Razonamiento](#razonamiento--pensamiento-extendido) y [Temperatura](#temperatura) para los campos que Kodus bloquea u oculta según el modelo.
Haz clic en **Test** para sondear el proveedor, o en **Test & save** para ejecutar la prueba y persistir si tiene éxito. Agrega tantos modelos al proveedor como quieras — la clave solo se pega una vez.
**Agrega otro proveedor** en cualquier momento desde la pestaña Providers. Cada proveedor mantiene su propia clave; habilitar más modelos en un proveedor conectado nunca la vuelve a pedir.
## Prueba antes de guardar
El botón **Test** verifica tu configuración antes de que pueda romper una revisión real. Lo que hace depende del proveedor:
| Proveedor | Qué hace Test |
| ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Marcas compatibles con Anthropic** (Kimi, Z.ai, DeepSeek), **OpenAI-compatible**, **Novita** | Envía una **solicitud de chat real de 1 token** al modelo exacto — la misma llamada que hace una revisión. Detecta un ID de modelo incorrecto, una clave restringida y problemas del endpoint en el acto. |
| **OpenAI, Anthropic, Google (Gemini/Vertex), OpenRouter, Bedrock** | Una llamada económica de identidad/metadatos (list-models, token exchange o STS) — confirma que la clave y el endpoint funcionan. |
En la vía de sondeo por chat, Test también **valida el ajuste que configuraste contra las propias reglas del modelo** y devuelve un error temprano y específico en lugar de guardar una configuración que el modelo ignoraría en silencio:
* Una temperatura que un modelo que siempre razona no respetará (está fijada en `1` — consulta [Temperatura](#temperatura)).
* Razonamiento en **Off** en un modelo que siempre razona y no puede deshabilitarse.
Como los proveedores de chat ahora ejercitan el modelo real, un **error de tipeo en el ID del modelo se detecta en el momento de Test** en lugar de en tu primera revisión — la respuesta vuelve como `Model not found`.
## Enrutamiento: qué modelo ejecuta cada tarea
Una vez que conectas dos o más modelos, la pestaña **Routing** decide qué modelo ejecuta qué. El enrutamiento es **plano**: cada tarea usa el predeterminado hasta que lo anulas.
**Manual · you choose** está activo hoy. **Auto · Kodus optimizes** llegará pronto.
* **Model for all tasks** — el único modelo que usa cada tarea a menos que se anule.
* **Fallback (opcional)** — un modelo *distinto* en el que Kody vuelve a ejecutar una llamada una vez cuando el modelo de la tarea falla: una clave mala o vencida, sin crédito, o el proveedor caído (después de sus propios reintentos).
Distintas tareas de Kody (revisión de código, Kody Rules, chat, resúmenes y más) pueden ejecutar cada una un modelo diferente — un modelo más caro para revisión profunda, uno más barato para resúmenes. Un modelo que no puede realizar una tarea dada aparece deshabilitado en esa fila con un tooltip, antes de que puedas guardarlo.
Haz clic en **Save routing** para persistir. **Reset agents to default** devuelve todas las anulaciones por agente al predeterminado y limpia el respaldo (el propio modelo predeterminado se conserva). Un panel de solo lectura **Per repository** más abajo refleja cualquier anulación de modelo por repositorio definida en Code Review Settings.
Con un único modelo conectado, el enrutamiento se omite — cada tarea usa ese modelo. Conecta un segundo modelo para que el enrutamiento tenga sentido.
## Elegir modelos
Cualquier modelo que sirva tu proveedor funciona. Si no sabes por dónde empezar, estas son opciones sólidas para revisión de código:
**Mejor equilibrio / calidad insignia.** El razonamiento extendido adaptativo de Anthropic y un sólido análisis entre archivos. Claves: [console.anthropic.com](https://console.anthropic.com/settings/keys).
**Mayor contexto.** El modelo insignia de Google — el más robusto en PRs grandes y monorepos. Claves: [aistudio.google.com/apikey](https://aistudio.google.com/apikey).
**Rápido y consistente.** La línea insignia de OpenAI — latencia baja confiable, conocimiento amplio. Claves: [platform.openai.com/api-keys](https://platform.openai.com/api-keys).
**El más económico vía suscripción.** Kimi de Moonshot y GLM de Z.ai ofrecen planes de código a tarifa plana que limitan el gasto mensual. Consulta [Conectar Kimi y GLM](#conectar-kimi-moonshot-y-glm-zai) más abajo.
**Nuestra recomendación predeterminada:** comienza con **Claude Sonnet** para la mejor experiencia general. Si el costo es prioridad, un **GLM Coding Plan** o un **Kimi Code Plan** ofrecen una suscripción a tarifa plana. Ingresa el ID exacto del modelo que documenta tu proveedor — Kodus deriva el nombre visible a partir de él.
## Conectar Kimi (Moonshot) y GLM (Z.ai)
Moonshot y Z.ai ofrecen cada uno un plan de suscripción en un **endpoint distinto** al de su Developer API de pago por token. Cada plan es una cuenta separada con su propia clave — elige la base URL que coincida con la clave que tienes.
| Plan | Endpoint | Claves desde | Ideal para |
| ------------------ | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------- |
| **Developer API** | `https://api.moonshot.ai/v1` (OpenAI-compatible) o `https://api.moonshot.ai/anthropic` (Anthropic-compatible) | [platform.moonshot.ai](https://platform.moonshot.ai/console/api-keys) | Pago por token, la concurrencia escala con el nivel de recarga |
| **Kimi Code Plan** | `https://api.kimi.com/coding/v1` | [kimi.com/code](https://www.kimi.com/code) | Suscripción con un endpoint de código dedicado |
El Kimi Code Plan está documentado con un tope de 30 solicitudes concurrentes — define `maxConcurrentRequests=30`. Las variantes de Kimi que siempre razonan (por ejemplo, `kimi-k2p7-code`, `kimi-k3`) fijan la temperatura en `1` y no pueden apagar el razonamiento — consulta [Temperatura](#temperatura).
| Plan | Endpoint | Claves desde | Ideal para |
| ----------------- | ------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------- |
| **Developer API** | `https://api.z.ai/api/paas/v4/` | [z.ai/manage-apikey](https://z.ai/manage-apikey/apikey-list) | Cargas variables, pago por token |
| **Coding Plan** | `https://api.z.ai/api/coding/paas/v4` | [z.ai/subscribe](https://z.ai/subscribe) | Volumen predecible de equipo, tarifa mensual fija |
Las claves del GLM Coding Plan **solo** funcionan en `/api/coding/paas/v4`. Los niveles Lite y Pro suelen estar limitados a **1 solicitud concurrente** — define `maxConcurrentRequests=1` y súbelo (hasta 30) solo en el nivel Max.
## Proveedores compatibles
**Ideal para:** Los últimos modelos GPT y rendimiento confiable.
**Obtener una clave de API:**
1. Visita [OpenAI API Keys](https://platform.openai.com/api-keys)
2. Crea una nueva clave para Kodus
3. Agrega información de facturación
**Ideal para:** Revisiones con gran contexto (1M tokens) y precios competitivos.
**Obtener una clave de API:**
1. Ve a [Google AI Studio](https://aistudio.google.com/app/apikey)
2. Crea una nueva clave
3. Habilita la facturación en Google Cloud Console
**Ideal para:** Análisis detallado y razonamiento extendido adaptativo.
**Obtener una clave de API:**
1. Visita [Anthropic Console](https://console.anthropic.com/)
2. Crea una cuenta y genera una clave
3. Agrega créditos
**Ideal para:** Modelos de código abierto y alojados (Llama, DeepSeek, Kimi) a precios competitivos.
**Obtener una clave de API:**
1. Regístrate en [Novita AI](https://novita.ai/)
2. Navega a la configuración de API
3. Genera una clave
Configuración detallada con capturas de pantalla.
**Ideal para:** Una sola relación de facturación para muchos modelos.
**Obtener una clave de API:**
1. Crea una cuenta en [OpenRouter](https://openrouter.ai/)
2. Agrega créditos
3. Genera una clave en la configuración
OpenRouter enruta cada solicitud a un proveedor upstream diferente por defecto, lo que puede provocar variación de calidad y latencia entre llamadas. **Fija upstreams específicos** en Advanced settings → OpenRouter routing para mantener un comportamiento estable. Consulta [Fijar proveedores de OpenRouter](#fijar-proveedores-de-openrouter).
**Beta.** Una vía de autenticación más compleja que la norma de clave única.
**Ideal para:** Equipos ya en Google Cloud que necesitan Gemini (o Claude) bajo la facturación, el IAM y las garantías de residencia de datos que ya tienen en GCP.
**Cómo configurarlo:**
1. En el flujo de conexión, elige **Google Vertex AI** (bajo Custom).
2. Pega el **contenido de tu archivo JSON de service account** en el campo Service Account JSON (base64 también funciona). Kodus extrae `project_id` del JSON automáticamente.
3. **Region** — déjalo vacío para usar el endpoint global (recomendado). Fija una región (p. ej. `us-east5`) solo si tienes requisitos de residencia de datos.
La service account necesita permiso para llamar a la API de predicción de Vertex AI en ese proyecto. Test sondea el *modelo realmente configurado*, así que un modelo/región no disponible falla en el momento de Test.
**Beta.** Una vía de autenticación más compleja que la norma de clave única.
**Ideal para:** Equipos estandarizados en AWS que quieren los modelos facturados en su propia cuenta de AWS.
**Cómo configurarlo:**
1. En el flujo de conexión, elige **Amazon Bedrock** (bajo Custom).
2. Proporciona una **Bedrock API key** (bearer token) — consulta [cómo generar una Bedrock API key](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-generate.html).
3. Define la **Region** (p. ej. `us-east-1`, `us-west-2`, `eu-central-1`).
Si tu equipo aún no ha migrado a Bedrock API keys, despliega **Advanced — use IAM user credentials instead** e introduce un access key ID + secret estáticos (más un session token para credenciales temporales de STS). El principal IAM necesita `bedrock:InvokeModel`.
La API key tiene prioridad: si hay un bearer token, los campos de IAM se ignoran.
**Ideal para:** Proveedores especializados (Moonshot, Z.ai, Fireworks, Together, Groq, DeepSeek) o endpoints auto-alojados.
**Cómo configurar:**
1. En el flujo de conexión, elige **OpenAI Compatible** (bajo Custom).
2. Ingresa la URL base (por ejemplo, `https://api.moonshot.ai/v1`, `https://api.z.ai/api/paas/v4/`, `https://api.fireworks.ai/inference/v1`).
3. Proporciona la clave y el ID del modelo.
Los IDs de modelo son específicos de cada proveedor — algunos usan rutas profundas (por ejemplo, Fireworks: `accounts/fireworks/models/kimi-k2p7-code`). Copia el ID exacto desde el panel de tu proveedor; Test envía una solicitud real, así que un ID incorrecto falla de inmediato.
Configuración completa de Z.ai con detalles del Coding Plan.
Configuración de Kimi + Kimi Code Plan.
Configuración específica de Fireworks.
Configuración de Together AI.
**Ideal para:** Endpoints que hablan la API Messages de Anthropic en lugar de la de OpenAI — incluidos endpoints de coding plan como el de Kimi.
**Cómo configurarlo:**
1. En el flujo de conexión, elige **Anthropic-compatible** (bajo Custom).
2. Introduce la base URL, la clave y el model ID.
Pega la base URL en el formato que documente tu proveedor — con o sin `/v1` al final (p. ej. `https://api.kimi.com/coding` o `https://api.kimi.com/coding/v1`). Kodus la normaliza internamente, porque las dos vías del SDK de Anthropic no coinciden en dónde va el `/v1`. Para una marca conocida, una conexión solo con la clave resuelve el endpoint automáticamente.
## Razonamiento / Pensamiento extendido
El formulario **Add a model** expone un interruptor **Thinking** (Off / Low / Medium / High / Custom) bajo **Advanced settings**. Las opciones disponibles reflejan lo que el modelo realmente puede hacer:
* Un modelo que no puede razonar queda bloqueado en **Off** con una nota.
* Un modelo que solo razona en ciertos niveles (por ejemplo, medium/high de GPT-5) deshabilita los inválidos.
* Un modelo que razona por defecto obtiene **Medium** como punto de partida razonable.
### Niveles predefinidos
Cuando eliges Low / Medium / High, Kodus traduce el nivel al formato nativo de cada proveedor automáticamente:
| Proveedor | Cómo se mapea "medium" |
| ------------------------------------------------------------------ | -------------------------------------------------------------------- |
| **Anthropic** (Claude adaptativo) | `thinking: { type: "adaptive" }` + `effort: "medium"` |
| **Google** (Gemini) | `thinkingConfig: { thinkingLevel: "medium" }` |
| **OpenAI** (GPT-5 / serie o) | `reasoningEffort: "medium"` |
| **OpenRouter** | `reasoning: { effort: "medium" }` |
| **OpenAI-compatible / Anthropic-compatible** (Kimi, GLM, DeepSeek) | `thinking: { type: "enabled" }` — binario on/off, el nivel se ignora |
Kimi y GLM actualmente exponen el razonamiento como un único indicador on/off. Elegir Low, Medium o High emite el mismo payload (thinking habilitado). Las **variantes que siempre razonan** (Kimi `k2p7-code`/`k3`, GLM-5.3) razonan incondicionalmente — no se pueden poner en Off, y el formulario deshabilita esa opción.
### Sobrescritura con JSON personalizado
Elegir **Custom** en el interruptor de Thinking revela un área de texto JSON. Pega directamente las opciones del proveedor — **Kodus las envuelve automáticamente bajo el namespace del proveedor activo**. No necesitas conocer las reglas de enrutamiento del Vercel AI SDK.
Úsalo cuando:
* Necesitas un valor específico de `budgetTokens` para Claude (en lugar del mapeo predefinido de esfuerzo)
* Quieres habilitar/deshabilitar el razonamiento por modelo en proveedores compatibles con OpenAI
* Quieres campos más allá del razonamiento — **caching, service tier, safety settings, etiquetado `user`, etc.** La sobrescritura se fusiona en `providerOptions`, por lo que cualquier campo del adaptador pasa
* El proveedor lanza un nuevo campo que Kodus aún no ha envuelto
#### Ejemplos (pega directamente — sin namespace)
Sobrescribir el presupuesto de pensamiento de Claude a exactamente 20,000 tokens:
```json theme={null}
{
"thinking": { "type": "enabled", "budgetTokens": 20000 }
}
```
Habilitar el caching de prompts (ejemplo no relacionado con razonamiento):
```json theme={null}
{
"cacheControl": { "type": "ephemeral" }
}
```
Presupuesto de pensamiento explícito (Gemini 2.5) o nivel (Gemini 3+):
```json theme={null}
{
"thinkingConfig": { "thinkingBudget": 16000 }
}
```
Ajustar los safety settings:
```json theme={null}
{
"safetySettings": [
{ "category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE" }
]
}
```
Razonamiento con campos específicos de OpenAI:
```json theme={null}
{
"reasoningEffort": "high",
"serviceTier": "flex",
"store": false,
"user": "kodus-review"
}
```
Forzar razonamiento + ignorar un upstream específico:
```json theme={null}
{
"reasoning": { "effort": "high" },
"ignore": ["deepinfra"]
}
```
Habilitar pensamiento con una sugerencia de presupuesto:
```json theme={null}
{
"thinking": { "type": "enabled", "budget_tokens": 25000 }
}
```
Deshabilitar explícitamente el pensamiento (solo en un modelo que lo soporta):
```json theme={null}
{
"thinking": { "type": "disabled" }
}
```
Los campos que el proveedor upstream no reconoce (por ejemplo, `budget_tokens` en un servidor que lo ignora) se descartan silenciosamente. Consulta la documentación del proveedor para confirmar qué acepta.
#### Modo manual con namespaces (usuarios avanzados)
Si tu JSON ya empieza con una clave de namespace conocida en el nivel superior — cualquier clave de la tabla de mapeo de abajo — Kodus lo deja intacto. Útil si quieres mezclar múltiples namespaces de proveedores o ser explícito:
```json theme={null}
{
"openrouter": {
"reasoning": { "effort": "high" },
"provider": { "order": ["moonshot"], "allow_fallbacks": false }
}
}
```
Internamente, estos son los mapeos de namespace que Kodus usa:
| Proveedor BYOK | Clave de namespace |
| ------------------------------------ | ------------------------------------------------------- |
| `anthropic` / `anthropic_compatible` | `anthropic` |
| `google_gemini` | `google` |
| `google_vertex` | `google` para Gemini, `anthropic` para Claude en Vertex |
| `openai` | `openai` |
| `openai_compatible` | `openaiCompatible` |
| `azure` | `azure` |
| `amazon_bedrock` | `amazonBedrock` (también acepta `bedrock`) |
| `novita` | `novita` |
| `open_router` | `openrouter` |
#### Detalles a tener en cuenta
* **Solo JSON válido.** Las comas faltantes o sobrantes rompen el análisis y Kodus ignora la sobrescritura.
* **Precedencia:** la sobrescritura JSON **reemplaza por completo** el bloque de namespace del preset de esfuerzo — si sobrescribes `anthropic.thinking` pero olvidas `anthropic.effort`, ese campo no se enviará. El enrutamiento de OpenRouter (Pin providers / Allow fallbacks) es la única excepción: se fusiona en profundidad con tu sobrescritura bajo `openrouter`.
* **Proveedor desconocido = sin envoltura.** Si tu proveedor de BYOK no está en la tabla de namespaces anterior, Kodus pasa el JSON tal cual.
## Temperatura
La temperatura vive bajo **Advanced settings**, y el campo se adapta a las reglas del modelo — definidas por el proveedor, no adivinadas por el formulario:
| Modelo | Campo de temperatura |
| ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| La mayoría de los modelos | **Editable** (0 = determinista, 2 = creativo). |
| Modelos de protocolo Anthropic que siempre razonan (Kimi `k2p7-code`/`k3`, GLM-5.3) | **Bloqueado en `1`.** El protocolo fija la temperatura en 1 mientras piensa, así que 1 es el único valor sólido — el campo muestra un candado y Kodus envía `1` sin importar lo que se haya guardado. |
| Claude 4.7+ y OpenAI GPT-5 / serie o | **Oculto.** Estos modelos eliminaron la temperatura y rechazan cualquier solicitud que la defina — dirígelos con el nivel de razonamiento en su lugar. |
En los proveedores de sondeo por chat, [Test](#prueba-antes-de-guardar) valida la temperatura que definas contra estas reglas y devuelve un error antes de guardar — para que nunca persistas un valor que el modelo no respetará.
## Fijar proveedores de OpenRouter
OpenRouter es un enrutador — cuando solicitas un modelo (por ejemplo, `moonshotai/kimi-k2`), reenvía la llamada a uno de varios proveedores upstream (Moonshot directo, Together, Groq, Fireworks, Novita…). Cada llamada puede caer en un backend diferente. Es conveniente, pero introduce variación silenciosa:
* **Variación de calidad** — los upstreams corren diferentes precisiones (FP8, INT4, completa) y entregan salidas sutilmente distintas para prompts idénticos
* **Inconsistencia en tool-calling** — algunos backends no soportan function calling de la misma forma, lo que provoca llamadas a herramientas mal formadas
* **Variación en el formato de razonamiento** — un upstream respeta `reasoning_effort`, otro solo `thinking.enabled`, otro ignora ambos
* **Oscilaciones de latencia** — el p50 puede saltar de 800ms a 4s entre llamadas a medida que cambia el enrutamiento
* **Sorpresas de rate-limit** — alcanzas la cuota en un backend que no elegiste explícitamente
### Cómo fijarlos
Cuando tu proveedor de BYOK es **OpenRouter**, el panel de Advanced settings muestra una sección **OpenRouter routing** con dos campos:
* **Pin providers (in order)** — lista separada por comas de nombres de upstream (por ejemplo, `moonshot, together`). OpenRouter los prueba en orden y usa el primero disponible.
* **Allow fallbacks** — cuando está desactivado, las solicitudes fallan de forma contundente si ninguno de los proveedores fijados está disponible. Cuando está activado (valor por defecto), OpenRouter puede recurrir a cualquier otro upstream que sirva el modelo.
Para una configuración **estable**, fija un único proveedor y desactiva los fallbacks (`Pin: moonshot`, `Allow fallbacks: off`). Las solicitudes siempre impactarán en el mismo upstream o fallarán de forma ruidosa — sin cambios silenciosos de calidad. La contrapartida es cero resiliencia si ese upstream se cae; emparéjalo con un Routing Fallback distinto (por ejemplo, Anthropic) para absorber las caídas.
Los nombres de upstream deben coincidir con el catálogo de OpenRouter. Revisa las etiquetas de proveedor en [openrouter.ai/docs/features/provider-routing](https://openrouter.ai/docs/features/provider-routing) — los valores comunes incluyen `moonshot`, `together`, `groq`, `fireworks`, `novita`.
Internamente, Kodus emite esto en la llamada del Vercel AI SDK:
```json theme={null}
{
"openrouter": {
"provider": {
"order": ["moonshot", "together"],
"allow_fallbacks": false
}
}
}
```
### Avanzado: sobrescritura con JSON en crudo
Si necesitas campos más allá de `order` y `allow_fallbacks` (por ejemplo, `ignore`, `data_collection`, `require_parameters`), cambia **Thinking** a **Custom** en Advanced settings y pega el payload de enrutamiento completo — se fusiona en `providerOptions` junto con cualquier configuración de razonamiento:
```json theme={null}
{
"openrouter": {
"provider": {
"order": ["moonshot"],
"allow_fallbacks": false,
"ignore": ["deepinfra"],
"data_collection": "deny"
},
"reasoning": { "effort": "medium" }
}
}
```
## Concurrencia y límites de tasa
El campo `maxConcurrentRequests` (bajo **Advanced settings**) limita cuántas solicitudes en curso envía Kodus a tu proveedor en paralelo. La mayoría de las veces, el valor predeterminado es suficiente — pero los planes de suscripción con topes de concurrencia estrictos necesitan configurarlo explícitamente.
### Valores a definir
| Proveedor / plan | Valor | Por qué |
| -------------------------------------------- | ---------- | ---------------------------------------------------------------------------------- |
| **GLM Coding Plan (Lite/Pro)** | `1` | La suscripción solo permite una solicitud en curso. Subirlo dispara errores 429. |
| **GLM Coding Plan (Max)** | hasta `30` | Max permite hasta 30 concurrentes — súbelo aquí para usar el presupuesto completo. |
| **Kimi Code Plan** | `30` | Tope documentado por Moonshot en el endpoint de código. |
| **GLM Developer API** | *(vacío)* | Los límites escalan por clave; sin un valor global razonable. |
| **Kimi Developer API** | *(vacío)* | Escala con tu nivel de recarga (Tier 1 ≈ 50, Tier 5 ≈ 1000). |
| **Anthropic / OpenAI / Google / OpenRouter** | *(vacío)* | Los proveedores aplican sus propios TPM/RPM; Kodus no lo limita. |
### Cuándo ajustarlo
* Tienes un nivel de recarga alto en Moonshot/OpenRouter y quieres más rendimiento en PRs grandes
* Actualizaste tu GLM Coding Plan a **Max** y quieres usar el presupuesto completo de 30 concurrentes
* Las revisiones se sienten serializadas en PRs con múltiples archivos y no ves errores 429
* Ves errores `429` o `Too much concurrency` en los logs de revisión
* Tu proveedor advierte sobre límites de tasa en el panel
* Quieres conservar la ventana del Coding Plan (5h/semanal) entre más PRs
**Concurrencia vs. RPM vs. TPM.** `maxConcurrentRequests` solo limita las solicitudes en curso en paralelo. Muchos proveedores también aplican límites separados de **RPM** (solicitudes por minuto) y **TPM** (tokens por minuto). Si estás alcanzando RPM/TPM mientras la concurrencia se ve bien, la solución suele ser subir de nivel o distribuir la carga en el tiempo — no cambiar `maxConcurrentRequests`.
**Interacción con el respaldo.** Cuando el modelo de una tarea recibe un 429 y Kody conmuta al Routing Fallback, se aplica el `maxConcurrentRequests` del propio Fallback. Configurar un Fallback generoso en un proveedor distinto es una buena forma de absorber ráfagas cuando tu modelo principal está en una suscripción ajustada.
## Mejores prácticas
### Seguridad
Crea claves de API separadas para Kodus. Facilita la auditoría de uso y la rotación de claves.
Rota las claves periódicamente y actualízalas en la configuración de BYOK.
Revisa los paneles de tu proveedor para detectar patrones inusuales.
Nunca confirmes claves en repositorios. Kodus las almacena cifradas en reposo y en tránsito.
### Estrategia de enrutamiento
* Usa un **proveedor diferente** para tu predeterminado y tu respaldo (por ejemplo, Anthropic predeterminado, Google respaldo). Protege contra interrupciones específicas del proveedor.
* Las suscripciones con límites de concurrencia estrictos (GLM Coding Plan Lite/Pro, Kimi Code Plan) son malas configuraciones en solitario — empárlalas con un respaldo de pago por token para que los PRs variables no se queden sin recursos.
* Enruta las tareas pesadas (revisión de código profunda) a tu modelo más fuerte y las ligeras (resúmenes, chat) a uno más barato en **Per agent**.
## Solución de problemas
* Copia la clave sin espacios extra, comillas o saltos de línea al final.
* Confirma que la facturación esté habilitada y la cuenta tenga créditos.
* Para claves del GLM Coding Plan / Kimi Code Plan, asegúrate de que la **base URL** coincida con el plan — las claves de suscripción no funcionan en el endpoint del Developer API y viceversa.
* Para los proveedores de sondeo por chat (Anthropic-compatible, OpenAI-compatible, Novita), Test envía una solicitud real al modelo, así que un ID de modelo incorrecto o mal escrito falla aquí — esto es lo esperado y mejor que fallar en el momento de la revisión.
* Copia el ID exacto del modelo desde el panel del proveedor. Algunos proveedores usan rutas profundas (por ejemplo, Fireworks `accounts/fireworks/models/kimi-k2p7-code`) o escriben las versiones de otra forma (`k2p7` vs `k2.7`).
* Verifica que la base URL coincida exactamente con el proveedor (la barra al final importa para algunos).
* Para proveedores compatibles con OpenAI, el endpoint suele ser `{baseURL}/chat/completions` (Kodus agrega la ruta).
* Algunos modelos fijan la temperatura o siempre razonan (Kimi `k2p7-code`/`k3`, GLM-5.3; Claude 4.7+/GPT-5 eliminan la temperatura por completo). Test valida tu ajuste contra las reglas del modelo y devuelve un mensaje específico — síguelo (deja la temperatura sin definir o usa el valor requerido; no pongas el razonamiento en Off en un modelo que siempre razona). Consulta [Temperatura](#temperatura).
* Baja **Max concurrent requests** en Advanced settings.
* En GLM Coding Plan Lite/Pro, mantente en **1 concurrente**. Actualiza a Max (30 concurrentes) si necesitas más rendimiento.
* En Kimi Code Plan, el tope documentado es **30 concurrentes**.
* Si Kodus está configurado mediante `.env` (Modo Fijo auto-alojado), la pantalla de BYOK muestra un banner informativo azul con el proveedor/modelo activo — la clave nunca se muestra por seguridad.
* Conectar un modelo y guardar sobrescribe la configuración de `.env`.
* El razonamiento agrega tokens. Si el costo se dispara, baja **Thinking** de Medium a Low, o enruta las tareas pesadas a un modelo más barato en **Per agent**.
* Consulta el panel de tu proveedor para el desglose por modelo, y establece un tope en la pestaña **Budget**.
## Preguntas frecuentes
Sí. El cambio surte efecto para la siguiente revisión — sin necesidad de redespliegue.
Las revisiones cambian automáticamente al Routing Fallback si hay uno configurado. Sin un Fallback, la revisión falla y devuelve un error. Siempre configura un Fallback.
Cada tarea usa el modelo predeterminado a menos que lo anules por agente en Routing. Si el modelo de una tarea falla (límite de tasa, 5xx, tiempo de espera, clave mala), Kody reintenta una vez en el Fallback. Solo pagas por el proveedor que efectivamente procesó la llamada.
Sí — para eso es **Routing → Per agent**. Enruta la revisión de código profunda a un modelo fuerte y los resúmenes o el chat a uno más barato. Necesitas al menos dos modelos conectados para que el enrutamiento tenga sentido.
Sí. Las claves se cifran en reposo y en tránsito y nunca se registran en texto plano. El endpoint de estado de BYOK nunca devuelve la clave en crudo.
Sí — mediante el proveedor **OpenAI Compatible** (bajo Custom). Ingresa la URL base de tu endpoint, el ID del modelo que expone y una clave de API de marcador de posición (la mayoría de los runtimes auto-alojados ignoran el header de la clave pero aún así requieren uno).