# Khala: define, construye, verifica y despliega tus propios agentes

> Khala es una plataforma para que los equipos de IT construyan y gobiernen los agentes de su organización — con su stack, en su nube y con el código en su repositorio. El equipo define la lógica y los tests, un agente de programación construye hasta superarlos y OverMind verifica por separado.

Fuente: https://www.renaiss.ai/es/khala · Código en tu GitHub o GitLab · Tus modelos y tus claves · SaaS, tu nube u on-premise

```shell
$ khala cases create --title "Disputed charges" --risk critical
Created CAS-1 · Disputed charges
$ khala cases move CAS-1 build
CAS-1 is now in build
$ khala new CAS-1
Created agent disputed-charges from CAS-1 (Pydantic AI, risk critical)
Repository: acme/agent-disputed-charges
```

## Qué hace Khala — y qué conserva IT

1. **Definir** — El equipo escribe la lógica del proceso y los tests que la defienden. Esa definición es la entrada de todo lo demás.
2. **Construir** — Un agente de programación trabaja en un sandbox hasta superar los tests visibles y después abre un pull request.
3. **Verificar y desplegar** — OverMind ejecuta los tests ocultos y calcula el Readiness Score. Sin superar sus gates, no hay promoción.

**Quién es dueño de qué**

| Activo | Dueño |
| --- | --- |
| Código del agente | El repositorio del cliente, en GitHub o GitLab |
| Framework | El que fije el cliente; Khala pide un contrato mínimo |
| Modelos y claves | Los del cliente, a través del gateway |
| Secretos | El vault del cliente; Khala guarda la referencia |
| Verificación | OverMind, separado de quien construye |
| Pipelines | Los runners del cliente |

## IT mantiene el control — y mantiene su stack

### Control: Nada se salta tu repositorio

Nada llega a producción sin pasar por tu repositorio, tu revisión y tus gates. Negocio define la lógica y los tests; IT fija los estándares y revisa cada pull request.

### El código: Código legible, sin lock-in

Cada agente es un repositorio en tu GitHub o GitLab, con código legible, tests y CI. No importa ninguna librería de Khala: si algún día dejas la plataforma, el agente sigue funcionando.

### El día a día: Khala asume el trabajo repetitivo

Construir contra los tests, verificar cada pull request, reunir evidencias para Riesgos y auditoría, y migrar agentes cuando cambia un estándar.

**Khala trabaja con lo que ya tienes**

| Capa | La tuya |
| --- | --- |
| Repositorio | GitHub o GitLab |
| Framework | El que fije el equipo, con su propio blueprint |
| Modelos | Tu proveedor y tus claves: Amazon Bedrock, Azure OpenAI, Vertex AI |
| Agente de programación | Claude Code, Codex o Antigravity |
| CI/CD | Tus runners; Argo CD o Flux |
| Identidad y secretos | Tu SSO y tu vault |
| Observabilidad | OpenTelemetry hacia tu monitorización y tu SIEM |
| Infraestructura | Tu nube o tu centro de datos, sobre Kubernetes |

## Tecnología soberana, agnóstica de modelos y técnicas

El cliente decide qué modelos y técnicas usar, dónde se ejecutan y quién opera la plataforma.

### 01 · Soberana: Bajo el control del cliente

Código, datos, claves y secretos pertenecen al cliente y se ejecutan en su nube o su centro de datos.

### 02 · Agnóstica de modelos: Ningún modelo obligatorio

El cliente elige el modelo y el proveedor, y puede cambiarlos. Cada cambio es un pull request que verifica OverMind.

### 03 · Agnóstica de técnicas: Ninguna técnica impuesta

RAG, framework, agente de programación y herramientas: Khala trabaja con los que fije el equipo y permite sustituirlos.

### Componentes de Renaiss: Propios

Renaiss tiene sus propios modelos y componentes, como su componente de RAG.

### Componentes de Renaiss: Configurables

Se configuran para cada organización y cada caso de uso.

### Componentes de Renaiss: Opcionales

El cliente puede usarlos o sustituirlos por los suyos; el resto de la plataforma no cambia.

## Khala complementa tu nube — no sustituye a tu equipo

Khala no vende cómputo ni modelos y no compite con los servicios de tu nube: los usa. El gasto en modelos va a la cuenta del cliente, con las claves del cliente.

1. **Tus agentes** (Capa 3) — Código en tu repositorio, desplegado en tus entornos.
2. **Khala** (Capa 2) — Definir, construir, verificar y gobernar.
3. **Tu nube y tus modelos** (Capa 1) — AWS, Azure, Google Cloud o tu centro de datos: cómputo, modelos, datos e identidad.

**Khala frente a un agente gestionado por un proveedor**

|   | Agente gestionado | Khala |
| --- | --- | --- |
| Qué compras | Un agente que el proveedor construye y opera | Una herramienta para construir y gobernar los tuyos |
| Dónde vive | En la plataforma del proveedor | En el repositorio y la nube del cliente |
| Alcance típico | Atención al cliente | Cualquier proceso con reglas y tests |
| Papel de IT | Integrar sistemas | Fijar estándares y revisar cambios |
| Cuando termina | El agente se queda en la plataforma | El código y los tests se quedan con el cliente |

> Si buscas un agente de atención al cliente llave en mano operado por un tercero, un agente gestionado llega antes. Khala es para equipos que quieren construir y gobernar sus agentes como el resto de su software.

## De un caso a producción en siete pasos

Cada agente nace de un caso: un proceso de negocio con un dueño, KPIs y un nivel de riesgo. Siempre sigue los mismos pasos, en la consola o en el terminal.

1. **Caso** — Proceso, dueño, KPIs y riesgo.
2. **Definir** — Lógica y tests.
3. **Conectar** — Herramientas, conocimiento y canales.
4. **Construir** — Build en un sandbox y pull request.
5. **Evaluar** — Suite, hallazgos y Readiness Score.
6. **Desplegar** — Entornos, promoción y release.
7. **Observar** — Trazas, coste y KPIs.

> Todo lo que puedes hacer con clics en la consola lo puedes hacer con un comando. El flujo de Git es siempre el mismo: rama, sandbox, pull request, merge y release.

## La entrada del builder es una definición, no un prompt

### Objetivo y alcance

Para qué sirve el agente y qué queda fuera de alcance. Todo lo que queda fuera se deriva a una persona.

### Pasos

El proceso, en orden. Cada paso indica quién decide: código fijo, el agente, un punto de decisión o el LLM.

### Reglas

“Cuando pase esto, el agente hace esto.” Cada regla necesita un test que falle si la regla se rompe.

### Límites

Lo que el agente nunca hace, lo que necesita aprobación humana y lo que se escala a una persona.

`agent/definition.yaml`

```yaml
logic:
  goal: Resolve disputes over unrecognized charges
  out_of_scope:
    - Confirmed fraud
  steps:
    - id: s-1
      kind: STEP_KIND_FIXED
      text: Verify the customer's identity
    - id: s-2
      kind: STEP_KIND_DECISION
      text: Classify the reason
  rules:
    - id: r-amount
      when: the amount exceeds 5,000
      effect: escalate to a person
  limits:
    - id: l-refund
      kind: LIMIT_KIND_APPROVAL
      text: Refund more than 2,000
version: 3
```

> Antes de construir, Khala cruza lógica y tests: señala reglas sin test, contradicciones y huecos — y pregunta.

## Tests visibles para construir, tests ocultos para verificar

### Visibles: El builder los lee

Viven en el repositorio, en evals/visible.jsonl, uno por línea. El builder construye hasta superarlos, y el equipo los edita como cualquier otro archivo.

### Ocultos: Solo OverMind los ve

Viven en un almacén al que solo accede OverMind y nunca entran en el sandbox de build. La proporción entre ambos la fija la Policy según el nivel de riesgo.

### De dónde salen los casos

Expertos del proceso, histórico (tickets, expedientes, transcripciones), casos sintéticos, trazas de producción, incidentes y ataques.

### Cómo se evalúan

Checks deterministas y de trayectoria, un juez con rúbrica, revisión humana y checks no funcionales — coste, latencia y carga — con umbrales por canal.

### Para que el builder no haga trampa

Tests y umbrales de solo lectura, variantes de cada caso en el momento de verificar y detección de valores esperados escritos a mano en el código.

> Un juez no cuenta como gate hasta que su acuerdo con las etiquetas humanas supera un umbral medido.

## Cuatro catálogos, un solo mecanismo

Cada activo se crea una vez, se prueba de forma aislada, se publica con un dueño y una versión, y lo reutiliza cualquier agente.

### 01: Herramientas

MCP Studio genera el servidor a partir de OpenAPI, WSDL, un esquema de base de datos, consultas SQL aprobadas o una función. Pasa de simulado a real sin tocar el código del agente.

### 02: Conocimiento

Ingesta incremental desde las fuentes del cliente. Permisos heredados de la fuente, citas obligatorias y una versión del índice ligada a cada release.

### 03: Skills

Solo del catálogo interno: revisadas, versionadas y con sus propias evals que miden cuándo se activan.

### 04: Canales

El equipo describe el canal y el builder escribe el adaptador, con sus plantillas y tests, en el mismo build.

**Entrada no confiable + Datos sensibles + Cambia estado** — Lint de diseño · regla de dos: un agente que combina las tres no puede actuar solo — todo lo que cambia estado requiere aprobación humana. Se comprueba al guardar la definición y otra vez en el check del pull request.

## Puntos de decisión: una pregunta cerrada, un umbral y un registro

Donde la respuesta se puede enumerar, el paso no es una llamada abierta al LLM: es un punto de decisión declarado en la definición, con las primitivas decide y extract.

**Anatomía de un punto de decisión**

| Campo | Ejemplo |
| --- | --- |
| Pregunta | ¿Cuál es el motivo de la disputa? |
| Tipo | Elección, puntuación, sí o no, o extracción |
| Opciones | duplicado · no reconocido · importe incorrecto |
| Regla previa | Lo que el código resuelve antes de preguntar |
| Umbral | 0.80 |
| Ruta de duda | Una persona o un LLM |
| Modelo | Fijado; cambiarlo es un PR que vuelve a medir |

### Shadow: Decide y registra, pero no actúa

Todo punto de decisión nace en este modo.

### Activo: Actúa cuando tiene evidencia

Cuando hay suficientes casos etiquetados y el umbral se ajustó con ellos.

### Apagado: Desactivado

El punto de decisión está desactivado.

### Registro de decisiones

Cada decisión se registra con sus probabilidades, el umbral, la versión del modelo, la ruta tomada y la etiqueta humana que llega después.

### Fallo seguro

Por debajo del umbral, o si el modelo no responde, el flujo toma la ruta de duda. Cada decisión es una actividad de Temporal.

## El builder es un agente de programación dentro de un sandbox

1. **Planner** — Lee la definición, detecta huecos y pregunta lo que falta, en una sesión separada de la que construye.
2. **Builder** — Escribe código en su rama hasta superar la suite visible. Si un test y una regla chocan, sale con un conflicto.
3. **Reviewer** — Empieza con un contexto limpio y un modelo de una familia distinta a la del builder.

### Motores: Claude Code, Codex y Antigravity

Los tres superan la misma suite de conformidad.

### Entrega: Un pull request, no una caja negra

El diff, el informe de tests, los supuestos, las preguntas abiertas y la preview. El log del build guarda el motor, el modelo, el coste y la transcripción.

**Permisos del sandbox de build**

| Recurso | Acceso |
| --- | --- |
| Tests, umbrales y Policy | Solo lectura |
| Tests ocultos | Fuera del sandbox |
| Credenciales de sistemas del cliente | Ninguna |
| Red | Solo a través del gateway |
| Escritura | Solo en su propia rama |

> Sin tests visibles, o sin una clave de modelo verificada para el builder, el build no arranca.

## El agente es el repositorio del cliente

Khala no impone un framework. Con tres piezas funcionan el playground, las evals y el despliegue — y un agente existente se incorpora añadiendo el manifiesto.

`agent-disputed-charges/`

```text
agent-disputed-charges/
├─ khala.yaml               manifest
├─ agent/
│  ├─ definition.yaml       logic, written by Khala
│  ├─ agent.py              the agent
│  ├─ invoke.py             standard invocation
│  └─ workflow.py           Temporal workflow
├─ tools/  knowledge/  channels/
├─ evals/
│  ├─ visible.jsonl         visible tests
│  └─ thresholds.yaml       thresholds
├─ overmind.policy.yaml     Policy
├─ tests/                   no network, no keys
└─ .github/workflows/ci.yml lint and tests
```

1. **khala.yaml** (Contrato) — Nombre, riesgo, framework, herramientas, conocimiento, canales, modelos, umbrales y entornos.
2. **Invocación estándar** (Contrato) — Un JSON de entrada y un JSON de salida, sea cual sea el framework.
3. **Trazas en OpenTelemetry** (Contrato) — Spans del agente, del modelo y de las herramientas, con coste y latencia.

> Git funciona en ambos sentidos: guardar en la consola crea un commit, y un push a la rama principal entra en Khala como una nueva versión. Si un archivo rompe el contrato, se rechaza indicando el motivo.

## OverMind verifica por separado y devuelve un Readiness Score

Cada gate parte de 100 y cada hallazgo abierto resta: Critical −25, High −10, Medium −4, Low −1.

| Gate | Peso | Qué cubre |
| --- | --- | --- |
| Seguridad | 35/100 | Red teaming, permisos y fugas. |
| Negocio | 30/100 | Tests ocultos y de regresión. |
| Robustez | 20/100 | Carga, latencia y coste por tarea. |
| Build | 15/100 | Auditoría del repositorio. |

### En cada pull request: Ocultos, regresión y red teaming básico

Más la auditoría del repositorio. Bloquea el merge ante un Critical o una regresión clara.

### En cada promoción: La suite completa

Carga, red teaming completo y coste por tarea. Devuelve la puntuación con sus cuatro gates.

### Cada noche: La misma suite, la misma versión

Te avisa cuando el agente se degrada sin que nadie toque el código.

## Cuatro entornos, cada uno con su propio gate de entrada

1. **Sandbox** — Uno por rama, efímero. Red denegada por defecto.
2. **Integración** — Recibe la release desde el sandbox. El paso previo al piloto.
3. **Piloto** — Entrada con gates en verde y aprobación de Riesgos.
4. **Producción** — Entrada con la suite por encima de su umbral y aprobación del dueño del caso.

### Segregación de funciones

Quien construyó el agente no puede aprobar su promoción. Lo impone el servidor, no la interfaz.

### Release inmutable

Commit, instrucciones, versiones de modelo, snapshot del índice, versiones de MCP, Policy y resultados de evals. Reproducible y reversible en un paso.

### Despliegue gradual

Por porcentaje, canal o segmento. Modo shadow junto al equipo. Un kill switch por agente y por herramienta.

> Khala genera los pipelines y la infraestructura como código en el repositorio del cliente. Argo CD o Flux los aplican.

## En producción: trazas, evals online y evidencias

Una traza dudosa va a la cola de revisión; lo que etiqueta el experto se suma a la suite. Cada incidente se convierte en un caso de regresión.

Traza de producción → Cola de revisión → Caso de test → Suite del agente

### Trazas

Spans del agente, del modelo y de las herramientas en OpenTelemetry, con coste, latencia y datos personales enmascarados. Exportadas a tu stack de observabilidad y tu SIEM.

### Evals online

Muestreo de trazas con jueces, más feedback de usuarios y escalados. Alimentan las alertas y la cola de revisión.

### Diff nocturno

OverMind repite la suite cada noche sobre la misma versión y te avisa si el agente se degrada sin cambios en el código.

### Expediente de evidencias

Por release y exportable: versiones de código, modelo, índice y MCP, resultados de evals y red teaming, la Policy vigente y las aprobaciones.

## El control se aplica fuera del modelo

Identidad, permisos y registro son deterministas: no dependen de lo que decida el agente.

### Identidad: SSO y mínimo privilegio

SSO con el proveedor de identidad del cliente. Cada agente tiene su propia identidad, con mínimo privilegio.

### Nivel de riesgo: Heredado del caso

Fija la plantilla de Policy, los gates y las aprobaciones.

### Gateway: Un único punto de entrada

Un solo punto para modelos, MCP y A2A: modelos permitidos, presupuestos y enmascaramiento de datos personales.

### Secretos: En tu vault

Khala guarda la referencia, nunca el valor.

### Auditoría: A prueba de manipulaciones

Cada entrada lleva el hash de la anterior, y la base de datos se niega a modificarla o borrarla.

**Permisos por perfil**

| Acción | FDE | Plataforma | Negocio | Riesgos | Ops |
| --- | --- | --- | --- | --- | --- |
| Ver casos y agentes | ✓ | ✓ | ✓ | ✓ | ✓ |
| Crear y modificar casos | ✓ | ✓ | ✓ | — | — |
| Crear agentes | ✓ | ✓ | — | — | — |
| Guardar la definición | ✓ | ✓ | — | — | — |
| Leer el log de auditoría | ✓ | ✓ | — | ✓ | — |

```shell
$ khala audit verify
Log intact: 128 entries checked.
```

## Los estándares de la organización se heredan y se aplican

La organización fija el punto de partida de cada agente; cada área cambia lo que permite el modo del estándar; el nivel más específico gana cuando el modo lo permite.

### Fijo: Nadie por debajo puede cambiarlo

Por ejemplo, los proveedores y modelos permitidos — el gateway solo enruta hacia ellos.

### Por defecto: Modificable dentro de las opciones permitidas

Por ejemplo, el framework y el motor del builder.

### Libre: Cada nivel decide

Se deja en manos del área o del agente.

**Dónde se aplican los estándares**

| Componente | Cómo |
| --- | --- |
| Builder | Los recibe como blueprint, AGENTS.md y skills |
| Sandbox | Limita el mirror de paquetes, las imágenes base y la red |
| Gateway | Solo enruta hacia proveedores y modelos permitidos |
| OverMind | Comprueba framework, dependencias, proveedor y convenciones |

> Un estándar es un archivo en Git. Cambiarlo es un pull request, que genera la lista de agentes afectados y un build de migración por agente, con sus tests como red de seguridad.

## Tres formas de desplegar la misma plataforma

En los tres modos, el código de los agentes, los modelos, las claves y los secretos pertenecen al cliente.

### 01 · SaaS: Operado por Renaiss

Instalamos, actualizamos y operamos la plataforma.

### 02 · Tu nube: En tu cuenta de nube

La misma plataforma, instalada en la cuenta de nube del cliente.

### 03 · On-premise: En tu centro de datos

Sobre el Kubernetes del cliente, sin salida a internet, con releases firmadas y un SBOM.

### Un solo paquete

La instalación es la misma en los tres modos; solo cambia la configuración.

### Sin recursos externos

La consola la sirve la propia plataforma y no carga nada de internet.

### Producción no se detiene

Si el plano de control cae, los agentes en producción siguen funcionando.

## Khala: preguntas frecuentes

### ¿Qué es Khala?

Khala es una plataforma de Renaiss para que los equipos de IT construyan y gobiernen los agentes de IA de su organización con su propio stack. El equipo define la lógica y los tests, un agente de programación (Claude Code, Codex o Antigravity) construye el agente en un sandbox aislado hasta superar los tests visibles y abre un pull request, y OverMind lo verifica por separado con tests ocultos.

### ¿De quién son los agentes construidos con Khala?

Del cliente. Cada agente es un repositorio en el GitHub o GitLab del cliente, con código legible, tests y CI, y no importa ninguna librería de Khala — si el cliente deja la plataforma, el agente sigue funcionando. Los modelos, las claves y los secretos también se quedan con el cliente.

### ¿Qué modelos, frameworks y agentes de programación admite Khala?

Khala es agnóstica de modelos y técnicas. Los clientes usan su propio proveedor y sus claves — por ejemplo Amazon Bedrock, Azure OpenAI o Vertex AI —, cualquier framework que cumpla un contrato mínimo (un manifiesto khala.yaml, una invocación JSON estándar y trazas de OpenTelemetry), y Claude Code, Codex o Antigravity como builder.

### ¿En qué se diferencia Khala de un agente gestionado por un proveedor?

Un agente gestionado lo construye y lo opera el proveedor en su plataforma, normalmente para atención al cliente. Khala es una herramienta para construir y gobernar tus propios agentes para cualquier proceso con reglas y tests: el código y los tests se quedan en tu repositorio y tu nube, e IT fija los estándares y revisa cada cambio.

### ¿Cómo evita Khala que el builder haga trampa con los tests?

El builder solo ve los tests visibles de evals/visible.jsonl. Los tests ocultos viven en un almacén al que solo accede OverMind y nunca entran en el sandbox de build; tests y umbrales son de solo lectura, cada caso recibe variantes en el momento de verificar y se detectan los valores esperados escritos a mano en el código.

### ¿Cómo llega un agente a producción con Khala?

A través de cuatro entornos — sandbox, integración, piloto y producción —, cada uno con su propio gate de entrada. El piloto exige los gates de OverMind en verde y la aprobación de Riesgos; producción exige la suite por encima de su umbral y la aprobación del dueño del caso. Quien construyó el agente no puede aprobar su promoción, y cada release es inmutable y reversible en un paso.

### ¿Puede Khala ejecutarse on-premise sin acceso a internet?

Sí. Khala funciona como SaaS operado por Renaiss, en la cuenta de nube del cliente o sobre el Kubernetes del cliente en su propio centro de datos, sin salida a internet, con releases firmadas y un SBOM. El paquete de instalación es el mismo en los tres modos, y los agentes en producción siguen funcionando si cae el plano de control.

### ¿Qué necesita un piloto de Khala?

Un caso real con un dueño y KPIs en un entorno de pruebas del cliente: un proceso con dueño, volumen y KPIs medibles, más un experto que aporte reglas y casos de test; una organización de GitHub para los repositorios, el proveedor de identidad y una clave de modelo; y un clúster de Kubernetes del cliente o una instancia de Renaiss, según el modo de despliegue.

## Qué necesita un piloto

Un caso real, con su dueño y sus KPIs, en un entorno de pruebas del cliente. Con eso se cubre todo el camino: definir, construir, verificar y desplegar.

1. **Un caso** — Un proceso con dueño, volumen y KPIs medibles, y un experto que aporte reglas y casos de test.
2. **Accesos** — Una organización de GitHub para los repositorios, el proveedor de identidad y una clave de modelo.
3. **Un entorno** — Un clúster de Kubernetes del cliente o una instancia de Renaiss, según el modo de despliegue.

Solicita una demo: https://www.renaiss.ai/es/khala#demo
