`.
4. **Archivo de ajustes**: el campo `model` de `~/.claude/settings.json`.
Comandos básicos:
```bash
# Iniciar con el modelo principal (actualmente Opus 5.5)
claude --model opus
# Cambiar a Sonnet durante una sesión
/model sonnet
# Abrir el menú de selección (para elegir de forma interactiva)
/model
# Cambiar a Opus con contexto de 1M
/model opus[1m]
# Cambiar a una versión específica (fijar)
/model claude-opus-5-5
```
Alias y modelos a los que apuntan en la API de Anthropic (a 23 de septiembre de 2026):
- `opus` → Opus 5.5 (requiere Claude Code v2.1.280 o posterior)
- `sonnet` → Sonnet 5
- `haiku` → Haiku 4.5
- `best` → el modelo disponible más inteligente
- `default` → Opus 5.5 en Pro, Max, Team, Enterprise y la API de Anthropic
- `opusplan` → un híbrido de Opus + Sonnet (se explica por separado más adelante)
⚠️ Los valores predeterminados varían según el proveedor en la nube: en Amazon Bedrock y Google Cloud, el alias `sonnet` apunta a Sonnet 4.5; en Microsoft Foundry, `opus` sigue resolviendo a Opus 4.6. Si trabajas mediante un proveedor en la nube, fija una versión concreta (`claude-opus-5-5`) o establece la variable `ANTHROPIC_DEFAULT_OPUS_MODEL`.
Desde la versión 2.1.144, el principal cambio es que `/model` ya no guarda la selección en los ajustes. Se aplica a la sesión actual y desaparece al cerrarla. Para guardar un valor predeterminado de forma permanente, pulsa `d` en la fila resaltada del menú de selección. Esto escribe el campo `model` en `~/.claude/settings.json`.
Las sesiones resumidas (`claude --resume`, `--continue`, `/resume`) conservan el modelo utilizado en esa sesión, independientemente del ajuste actual. Así se evita que otra sesión cambie el modelo al reanudarla.
Para comprobar qué modelo está activo, usa `/status`: muestra tanto la cuenta como el modelo actual.
## `/model opusplan`: compara por separado costes de planificación y ejecución
Puntos clave
`opusplan` es un alias híbrido: en Plan Mode piensa con Opus y al comenzar la ejecución cambia a Sonnet. El ahorro depende de tarifas y tokens reales de cada fase. En el ejemplo histórico siguiente, las tarifas 3/15 $ de Sonnet equivalen al 60 % de las 5/25 $ de Opus: un 40 % menos para la parte sustituida, no 75–80 % de toda la tarea.
En la práctica descrita aquí, este modo se usa para tareas que requieren más de 10 pasos.
La lógica:
- En Plan Mode (`/plan`), se debaten la arquitectura y las opciones y se acuerda un enfoque. Opus es caro en esta fase, pero justifica su precio porque su razonamiento es fundamentalmente distinto.
- En cuanto termina Plan Mode y Claude empieza a editar archivos, escribir pruebas y ejecutar comandos, comienza la ejecución. Para la ejecución, Sonnet 4.6 iguala la calidad de Opus.
Para activarlo:
```bash
# Al iniciar
claude --model opusplan
# O durante una sesión
/model opusplan
```
Un cálculo concreto. Supongamos que una refactorización de 50 pasos suele distribuirse así:
- Planificación (5 pasos, ~30,000 tokens de entrada + 8,000 de salida): Opus 4.7
- Ejecución (45 pasos, ~200,000 tokens de entrada + 50,000 de salida): Sonnet 4.6
| Opción | Coste de planificación | Coste de ejecución | Total |
|----|----|----|----|
| Solo Opus | \$0.15 + \$0.20 = \$0.35 | \$1.00 + \$1.25 = \$2.25 | **\$2.60** |
| Opusplan (Opus + Sonnet) | \$0.15 + \$0.20 = \$0.35 | \$0.60 + \$0.75 = \$1.35 | **\$1.70** |
La base usa 230.000 tokens de entrada y 58.000 de salida: 2,60 $ con las tarifas históricas Opus. Opusplan mantiene 30.000 de entrada y 8.000 de salida en Opus (0,35 $) y usa 200.000 de entrada y 50.000 de salida en Sonnet (1,35 $): total 1,70 $. El ahorro es (2,60−1,70)/2,60 = 34,6 %. Con idénticos tokens y tarifas, sustituir ejecución ahorra 40 % de esa parte; incluso si representa 90 % del coste base, el ahorro total sería 36 %. Una diferencia de tokenizador requiere cantidades explícitas de entrada y salida por modelo y no justifica por sí sola 75–80 %.
⚠️ Un detalle: Opus en el modo de planificación de `opusplan` usa el contexto estándar de 200K. La actualización automática a 1M, disponible con el alias `opus`, NO se aplica a `opusplan`. Si planificas una tarea enorme con millones de tokens de contexto (por ejemplo, analizar un monorepo grande), usa explícitamente `/model opus[1m]` o cambia a opusplan DESPUÉS de planificar.
## El comando `/effort`: 5 niveles de razonamiento adaptativo
Puntos clave
`/effort` controla la profundidad con la que piensa el modelo en cada paso. Los niveles son low, medium, high, xhigh (solo Opus 4.7) y max. Desde la versión 2.1.117, los valores predeterminados son xhigh para Opus 4.7 y high para los demás modelos. low/medium/high/xhigh se guardan entre sesiones; max solo se aplica a la sesión actual. En low, Opus se vuelve casi tan rápido y barato como Sonnet.
Es el segundo comando más importante después de `/model`. Effort es razonamiento adaptativo: en cada paso, el modelo decide cuánto debe pensar según la complejidad de la tarea. Cuanto más alto sea el nivel, más profundo será el razonamiento y más tokens utilizará.
Niveles (según la tarea):
| Nivel | Cuándo usarlo | Qué cambia |
|----|----|----|
| **low** | Tareas breves sin exigencias intelectuales: renombrar archivos, búsquedas grep sencillas, «¿qué hace esta función?», comando de compilación | El modelo apenas piensa y responde de forma rápida y barata |
| **medium** | Trabajo en el que ahorrar tokens importa más que una pequeña pérdida de precisión | Reduce el uso de tokens; a veces pierde precisión en los matices |
| **high** | El mínimo para tareas que requieren razonamiento real: programación, refactorización, revisión de código | Equilibra el uso de tokens y la calidad. Valor predeterminado de Sonnet 4.6 y Opus 4.6 |
| **xhigh** | Mejores resultados para la mayoría de las tareas de programación y de agentes | Valor predeterminado de Opus 4.7. Disponible solo en Opus 4.7 |
| **max** | Tareas muy exigentes. Puede mejorar los resultados, pero tiende a pensar demasiado | Sin límite de tokens. Se restablece al terminar la sesión |
Hay tres modelos compatibles: Opus 4.7, Opus 4.6 y Sonnet 4.6. Effort no está disponible en los demás.
Qué cambió en septiembre de 2026. Los niveles `low`, `medium`, `high`, `xhigh` y `max` están disponibles en Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 y Opus 4.7; Opus 4.6 y Sonnet 4.6 no tienen `xhigh`, y en esos modelos una solicitud de `xhigh` se ejecuta como `high`. El nivel predeterminado es `high` en todos los modelos compatibles con effort, excepto Opus 5.5 (`medium`) y Opus 4.7 (`xhigh`). Eso significa que hay que solicitar explícitamente un análisis profundo al modelo principal actual. También ha aparecido un modo independiente, `ultracode`: es un ajuste de Claude Code, no un nivel del modelo; envía `xhigh` y también pide a Claude que cree flujos de trabajo dinámicos para tareas grandes.
Cómo configurarlo:
```bash
# Abrir el control deslizante interactivo
/effort
# Establecer directamente el nivel
/effort high
/effort xhigh
# Restablecer el nivel predeterminado del modelo
auto
# Mediante una opción de lanzamiento
claude --effort high
# Mediante una variable de entorno (se aplica al iniciar)
export CLAUDE_CODE_EFFORT_LEVEL=high
# En los ajustes (max no funciona: max solo se aplica a la sesión)
{
"effortLevel": "high"
}
# En el frontmatter de un skill / subagente
---
name: my-skill
effort: low
---
```
El nivel aparece junto al logotipo y al indicador giratorio en Claude Code; por ejemplo, «con esfuerzo low», así que no hace falta abrir `/model` para comprobarlo.
El control de esfuerzo también aparece en el menú de selección de `/model`: usa las flechas izquierda/derecha para ajustarlo.
Un detalle importante. Al cambiar a Opus 4.7 desde cualquier otro modelo, el esfuerzo se establece obligatoriamente en xhigh, incluso si habías elegido high para Opus 4.6 o Sonnet 4.6. Para restablecer el nivel deseado, vuelve a ejecutar `/effort`.
Una técnica más: **ultrathink** en el prompt. Si incluyes la palabra `ultrathink` en el texto del prompt, Claude usará un razonamiento más profundo en ese turno sin cambiar el esfuerzo de la sesión. Expresiones similares («think», «think hard», «think more») no activan este comportamiento: simplemente se pasan como texto normal.
## El comando `/fast`: Opus es 2.5 veces más rápido por 6 veces el precio; ¿cuándo compensa?
Puntos clave
`/fast` es una configuración alternativa de la API para los modelos Opus principales. No es un modelo diferente: es el mismo Opus, pero hasta 2.5 veces más rápido al generar texto. A 23 de septiembre de 2026, es compatible con Opus 5.5, Opus 5 y Opus 4.8; cuesta \$8 / \$40 por millón de tokens en Opus 5.5 y \$10 / \$50 en Opus 5 y Opus 4.8. No está disponible en Sonnet ni Haiku, y se eliminó de Opus 4.7 el 24 de julio de 2026. Está pensado para depuración en directo y trabajo interactivo, cuando la latencia importa más que el dinero.
El modo rápido es una función en vista previa de investigación. Requiere Claude Code v2.1.36+ y se puede comprobar con `claude --version`.
Para activarlo:
```bash
# Activar o desactivar el modo rápido (disponible en la CLI de Claude Code y la extensión de VS Code)
/fast
# O en los ajustes
{
"fastMode": true
}
```
Una vez activado:
- Si estás usando otro modelo, Claude Code cambiará automáticamente a Opus.
- Aparecerá la confirmación «Fast mode ON».
- Aparecerá un icono `↯` junto al prompt.
Opciones y detalles:
- El modelo predeterminado en modo rápido es el Opus disponible más potente. A 23 de septiembre de 2026, es Opus 5.5; el modo rápido no funciona en absoluto con Opus 4.7 y cambiar a este modelo lo desactiva.
- El modo rápido se conserva entre sesiones de forma predeterminada. Los administradores de Team/Enterprise pueden exigir una activación explícita en cada sesión con `fastModePerSessionOptIn: true`.
- Al desactivar el modo rápido ejecutando `/fast` de nuevo, sigues usando Opus: el modelo no vuelve al que usabas antes. Para cambiar, usa `/model`.
- Activarlo a mitad de una conversación aplica el precio del modo rápido a todo el contexto de la conversación. Por eso resulta más económico activarlo al principio de la sesión, no a mitad.
Cuándo usar el modo rápido:
- **Depuración en directo**: estás observando una traza y el tiempo de respuesta es fundamental.
- **Fecha límite ajustada para trabajo interactivo**: estás preparando una demo para las 18:00 y necesitas iteraciones rápidas.
- **Iteración rápida de código**: estás comprobando hipótesis una tras otra.
Cuándo no usarlo:
- **Tareas autónomas largas** en las que la velocidad no sea esencial. Pagas 6 veces más por 2.5 veces la velocidad; no compensa si te vas a comer mientras Claude trabaja.
- **Procesamiento por lotes, pipelines de CI/CD**: no es en absoluto un modo interactivo.
- **Cargas sensibles al coste**: la elección es evidente.
Disponibilidad:
- NO funciona con Bedrock, Vertex ni Foundry.
- Requiere **créditos de uso** en la cuenta (facturación por encima del límite incluido en el plan). En las cuentas individuales, se activa en los ajustes de facturación de Console. En Team/Enterprise, debe activarlo un administrador.
- Los tokens del modo rápido NO se descuentan del límite incluido en el plan. Se cargan directamente a los créditos de uso, con las tarifas del modo rápido desde el primer token.
Si alcanzas el límite de solicitudes del modo rápido o te quedas sin créditos de uso, el modo rápido pasa automáticamente a la velocidad y los precios estándar, el icono `↯` se vuelve gris y el trabajo continúa. Cuando se restablece el límite, el modo rápido se activa de nuevo.
El modo rápido y effort no son ajustes incompatibles. Puedes combinarlos: modo rápido + low effort = velocidad máxima en tareas sencillas.
## Cuánto cuesta realmente cada modelo: desglose de la factura mensual
Puntos clave
Precios base por millón de tokens: Haiku 4.5: \$1 / \$5; Sonnet 4.6: \$3 / \$15; Opus 4.7: \$5 / \$25. Modo rápido: \$30 / \$150. La caché de prompts reduce a 0.1x el coste de las entradas repetidas. La API Batch ofrece un descuento del 50 %. La principal fuente de ahorro no es el modelo en sí, sino evitar Opus cuando Sonnet puede hacer el trabajo.
Precios por millón de tokens (API de Anthropic, USD):
| Modelo | Entrada | Escritura de caché de 5 min | Escritura de caché de 1 hora | Lectura de caché | Salida |
|------------------|-------|-------------------|-----------------|-----------|--------|
| Haiku 4.5 | \$1 | \$1.25 | \$2 | \$0.10 | \$5 |
| Sonnet 4.6 | \$3 | \$3.75 | \$6 | \$0.30 | \$15 |
| Opus 4.6 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Opus 4.7 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Modo rápido (Opus) | \$30 | n/a | n/a | n/a | \$150 |
Qué reduce realmente la factura:
1. **Caché de prompts.** Anthropic guarda en caché las partes repetidas de los prompts: el prompt del sistema, CLAUDE.md y las descripciones de herramientas. Leer de la caché cuesta el 10 % del precio de entrada. Con Sonnet, eso reduce \$3 por millón de tokens a \$0.30, diez veces menos. Se activa automáticamente mediante `cache_control: { type: "ephemeral" }` en la solicitud a la API. En Claude Code funciona de forma predeterminada.
2. **API Batch**: 50 % de descuento en entrada y salida para las tareas cuyos resultados puedes esperar (informes, generación de texto en lotes). Sonnet mediante la API Batch = \$1.50 / \$7.50. No funciona directamente en Claude Code, pero úsala si creas automatizaciones con el SDK de Anthropic.
3. **opusplan en lugar de Opus sin alternar**: aproximadamente 34,6 % en el ejemplo histórico; el total real depende de ejecución, tokens, tarifas, caché y reintentos.
4. **Sonnet por defecto + Opus cuando haga falta**: la principal fuente de ahorro. Si Opus está activado «por si acaso», en la práctica descrita aquí se cambia a Sonnet. Si la tarea requiere Opus, queda claro en el tercer o cuarto paso y cambio explícitamente con `/model opus`.
5. **Recuerda el nuevo tokenizador de Opus 4.7.** Con el mismo archivo, Opus 4.7 usa hasta un 35 % más de tokens que Sonnet 4.6. El coste real de la misma tarea aumenta más de lo que sugiere la tabla.
Un ejemplo concreto: una tarea típica de una agencia inmobiliaria que crea el prototipo de un sitio web para un cliente nuevo: «crea una página con tres secciones, un formulario e integración con una pasarela de pago». Los resultados fueron:
- Solo Opus 4.7 (high effort): ~\$4.80 por sesión (1.5 horas de trabajo).
- opusplan: ~\$1.90 (Opus planifica, Sonnet ejecuta).
- Solo Sonnet 4.6 (high effort): ~\$1.30, pero la decisión arquitectónica fue peor (Sonnet eligió un enfoque basado en plantillas, mientras que Opus en opusplan ideó uno propio para los requisitos no estándar).
El ganador para esta tarea es opusplan. El ahorro es del 60 %, con calidad de Opus en la parte crítica.
Claude Code no muestra directamente el número de tokens de los límites: estos son dinámicos y dependen del plan. Sin embargo, en `/status` puedes ver tu plan y el uso actual. Para un control más detallado, consulta esta guía: [Cómo evitar agotar los límites de Claude Code en un día](https://ailoot.ai/blog/es/claude-code-token-limits-saving/).
## ¿Qué flujo de trabajo diario deberías configurar? 4 ajustes predefinidos
Puntos clave
Cuatro ajustes predefinidos para distintos tipos de tareas. Programación diaria: Sonnet + high effort. Refactorización pesada: opusplan. Arreglo rápido: Haiku + low effort. Sesión de arquitectura: Opus 4.7 + xhigh effort + Plan Mode. Puedes guardar cada uno como alias, asociarlo a un skill o simplemente tenerlo a mano como primer comando al iniciar una sesión.
Estos cuatro ajustes predefinidos se pueden alternar según la jornada y la tarea.
**Ajuste 1. Programación diaria: el 80 % del tiempo de trabajo en la práctica descrita aquí.**
```bash
claude --model sonnet --effort high
# Dentro de la sesión, pasar a Opus si hace falta
/model opus
```
Para qué sirve: nuevas funciones, refactorizaciones pequeñas, depuración de errores sencillos, documentación. Sonnet con high effort es el punto ideal.
**Ajuste 2. Refactorización pesada: un cambio arquitectónico importante.**
```bash
claude --model opusplan
# Primero, usar /plan para hablar de la estructura
# Al salir de Plan Mode, Sonnet se ocupa de la ejecución
```
Para qué sirve: reescribir un módulo en más de 15 archivos, cambiar una integración de una pasarela a otra. Opus se ocupa de la arquitectura (analiza las dependencias), mientras que Sonnet se encarga de la ejecución (edita archivos rápidamente). Estas tareas pueden ahorrar más del 70 %.
**Ajuste 3. Arreglo rápido: ediciones de una línea y scripts.**
```bash
claude --model haiku --effort low
```
Para qué sirve: «cambia el nombre de una variable en todos los archivos», «escribe un script de bash para reiniciar nginx», «¿qué hace esta función?». Haiku resuelve estas tareas y cuesta tres veces menos que Sonnet.
**Ajuste 4. Sesión de arquitectura: una decisión estratégica.**
```bash
claude --model opus --effort xhigh
# Usar el esfuerzo máximo al entrar en Plan Mode:
/plan
# Añadir la palabra ultrathink al prompt para preguntas críticas
```
Para qué sirve: «¿X debería ser un servicio independiente?», «¿qué herramientas deberíamos usar para el prototipo?», «¿cómo deberíamos organizar un esquema de base de datos multiinquilino?». Aquí Opus 4.7 es caro, pero merece la pena, porque un error en este punto cuesta semanas de trabajo.
Estos ajustes se pueden guardar como Skills (un modelo por skill) o como alias en `~/.zshrc`:
```bash
alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'
```
Si trabajas en equipo, puedes estandarizar la configuración mediante ajustes gestionados. Un administrador establece `availableModels: ["sonnet", "haiku", "opusplan"]` en la política de la organización y los usuarios no pueden elegir Opus directamente, solo mediante autorización expresa. Es una buena protección frente a agotar el límite por accidente.
Quienes estén creando [subagentes](https://ailoot.ai/blog/es/claude-code-subagents/) también pueden definir modelos distintos para cada subagente mediante `CLAUDE_CODE_SUBAGENT_MODEL` o el campo `model` en el frontmatter de la definición del agente. Esto añade otro nivel de optimización.
## Qué hacer cuando te quedes sin capacidad: 5 técnicas prácticas
Puntos clave
Cuando alcances el límite de Opus, no te preocupes. Hay cinco formas de seguir trabajando: cambiar a Sonnet, usar opusplan, activar la caché de prompts, trasladar parte del trabajo a la API Batch o cambiar a Haiku para tareas secundarias. Los límites se duplicaron en mayo de 2026 y se eliminó la limitación durante las horas punta, por lo que ahora es más difícil agotar la capacidad de Opus.
Si `/status` indica que has alcanzado el límite de Opus:
1. **Cambia a Sonnet 4.6**: `/model sonnet`. Tiene un grupo de uso independiente y no notarás la diferencia en el 80 % de las tareas. Con la API de Anthropic, incluso si alcanzas el límite de Opus, Claude Code puede cambiar automáticamente a Sonnet si te acercas al umbral.
2. **Usa opusplan para el trabajo que queda**: `/model opusplan`. Si aún te quedan tareas en Plan Mode para el día, usarán Opus de forma mínima (solo para planificar); la ejecución se hará íntegramente con Sonnet.
3. **Comprueba la caché de prompts**: asegúrate de no haberla desactivado con `DISABLE_PROMPT_CACHING=1`. Si tu CLAUDE.md o prompt del sistema contiene un megabyte de ajustes, debería almacenarse en caché. Con un 90 % de lecturas, esto reduce el uso diez veces.
4. **Traslada las tareas por lotes**: si tienes generación masiva (informes, textos, traducciones), pásala a un script con la API Batch: 50 % de descuento en entrada y salida. No funciona directamente en Claude Code, pero se configura en 30 minutos con un script `tsx` + el SDK de Anthropic.
5. **Usa Haiku para tareas secundarias**: para tareas rutinarias como «escribe un mensaje de commit» o «explica qué hace este archivo», cambia Claude Code a Haiku. Consume tres veces menos que Sonnet y cinco veces menos que Opus.
Y el recordatorio principal: **desde el 6 de mayo de 2026, se duplicaron los límites de Pro, Max, Team y Enterprise**, y se eliminó la limitación durante las horas punta. Si Opus agota tu capacidad en medio día, el problema no son los límites: estás usando Opus para tareas que Sonnet podría resolver. El mapa de decisiones de la segunda sección de esta guía te ayudará a recuperar el control.
Para consultar a fondo los límites y ocho reglas prácticas para ahorrar tokens, lee este artículo de referencia: [Cómo evitar agotar los límites de Claude Code en un día: 8 reglas para ahorrar tokens en 2026](https://ailoot.ai/blog/es/claude-code-token-limits-saving/). Otro complemento útil es [Plan Mode en Claude Code: guía paso a paso](https://ailoot.ai/blog/es/claude-code-plan-mode/), porque opusplan no funciona sin Plan Mode. Y la base para todos los modelos es [Cómo configurar CLAUDE.md en 2026](https://ailoot.ai/blog/es/claude-md-template/).
### Fuentes
- [Anthropic: anuncio de Claude Opus 5.5 (22 de septiembre de 2026)](https://www.anthropic.com/news/claude-opus-5-5)
- [API de Anthropic: descripción general de modelos, precios y niveles de esfuerzo](https://platform.claude.com/docs/en/about-claude/models/overview)
- [Anthropic Claude Code: configuración del modelo](https://code.claude.com/docs/en/model-config)
- [Anthropic Claude Code: cómo acelerar las respuestas con el modo rápido](https://code.claude.com/docs/en/fast-mode)
- [Anthropic Claude Code: novedades](https://code.claude.com/docs/en/whats-new)
- [API de Anthropic: precios](https://platform.claude.com/docs/en/about-claude/pricing)
- [API de Anthropic: niveles de esfuerzo](https://platform.claude.com/docs/en/build-with-claude/effort)
- [API de Anthropic: ventana de contexto de 1M tokens](https://platform.claude.com/docs/en/build-with-claude/context-windows)
- [Soporte de Anthropic: modelos, uso y límites en Claude Code](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Blog de Anthropic: novedades de Claude Managed Agents (Code with Claude 2026)](https://claude.com/blog/new-in-claude-managed-agents)
Una configuración funcional para programar con IA: [documentación de Ailoot](https://ailoot.ai/docs/).
Más materiales y herramientas: [Ailoot](https://ailoot.ai/).
## Preguntas sobre Claude Code
### ¿Cuánto ahorra el ejemplo calculado de opusplan?
Con las tarifas y cantidades históricas de la tabla, solo Opus cuesta 2,60 $ y opusplan 1,70 $. El ahorro es 0,90/2,60, aproximadamente 34,6 %; no acredita un ahorro universal del 75–80 %.
### ¿Elegir un modelo de ejecución barato garantiza una tarea correcta más barata?
No. Usa cantidades reales de entrada, salida, caché y reintentos con las tarifas aplicables y las mismas comprobaciones de éxito. Una tarifa por token menor es solo parte del coste final.
## Ailoot · La empresa y su cartera de proyectos
Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI.
La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes.
Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.