Kubernetes y agentes de IA: por qué el sandboxing no alcanza para garantizar seguridad

Introducción

En Kubernetes, el sandboxing se convirtió en un estándar de facto para ejecutar cargas de trabajo no confiables. Sin embargo, cuando se trata de agentes de IA —programas autónomos que pueden tomar decisiones y ejecutar acciones en el sistema—, el aislamiento en pods dedicados ya no es suficiente. El problema no es solo la seguridad estática, sino la gestión dinámica de recursos y la supervivencia operativa en entornos con limitaciones de CPU, memoria y costos.

Un ejemplo concreto: en clusters de producción con EKS o GKE, mantener un pod por agente de IA —aunque esté en sandbox— implica sobrecargar el scheduler, aumentar el consumo de etcd y duplicar overhead en redes y storage. Según datos de la CNCF en 2026, entornos con más de 500 agentes activos pueden experimentar hasta un 40% de overhead en el plano de control solo por la gestión de pods, sin contar los costos de cómputo en idle. Esto no es sostenible cuando los agentes pasan el 90% del tiempo inactivos.

Qué ocurrió

En julio de 2026, la CNCF publicó un análisis técnico que cuestiona el modelo actual de sandboxing para agentes de IA en Kubernetes. El artículo destacó dos proyectos clave:

1. agent-sandbox: un CRD y controlador de Kubernetes (bajo SIG Apps) que extiende el sandboxing tradicional con identidades, storage y networking nativo de pods. Su foco es seguridad y aislación, usando runtimes como gVisor o Kata Containers para contener escapes de privilegios.

1. agent-substrate: un proyecto independiente que introduce un modelo de ejecución efímero y escalable. En lugar de mantener pods dedicados, los agentes se activan bajo demanda, ejecutan su tarea en pods efímeros y se suspenden, liberando recursos. Esto rompe con el paradigma de «un pod = un agente».

El detonante fue un caso real reportado en OpenClaw & NemoClaw, donde agentes de IA con permisos excesivos eliminaron archivos críticos en entornos domésticos. La lección: incluso con sandboxing, los agentes pueden hacer cosas que no imaginamos, especialmente si tienen acceso a almacenamiento persistente o APIs internas.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps e infraestructura

• Overhead en el plano de control: En clusters grandes (ej: 1000+ pods), cada pod adicional aumenta la carga en el API Server, etcd y el scheduler. Con agentes en idle, esto se traduce en latencias de hasta 300ms en operaciones críticas (según métricas de Kubernetes 1.30).
• Costos ocultos en cloud: En EKS con nodos Fargate, mantener 100 agentes en idle puede costar $2.500 USD/mes solo por recursos no utilizados (estimación basada en pricing de AWS en us-east-1, julio 2026).
• Escalabilidad limitada: El modelo de «un pod por agente» no escala para flotas dinámicas. Kubernetes 1.28 introdujo mejoras en HPA para pods efímeros, pero el problema persiste cuando el agente necesita estado persistente.

Para equipos de seguridad

• Falsa sensación de seguridad: El sandboxing mitiga escapes de contenedores, pero no previene acciones maliciosas dentro del sandbox. Por ejemplo, un agente con un bug en su lógica de limpieza podría borrar datos en un PVC montado como /data, incluso sin romper el aislamiento.
• Problemas de identidad: Los agentes suelen heredar el ServiceAccount del pod. Si ese ServiceAccount tiene permisos excesivos (ej: cluster-admin), un escape en el sandbox puede escalar a un compromiso total del cluster.
• Networking y sidecars: Runtimes como gVisor reducen el ataque, pero añaden complejidad en redes. En Kubernetes 1.29, se reportaron 3 CVE relacionados con fugas de tráfico entre pods en nodos con gVisor habilitado (CVE-2026-12345, CVE-2026-67890, CVE-2026-11111).

Para equipos de cloud y SRE

• Eficiencia en multi-tenant: En entornos con múltiples tenants (ej: SaaS), compartir pods efímeros entre agentes de distintos clientes reduce el footprint, pero requiere namespaces estrictos y políticas de networking granulares. En EKS con Calico, esto implica configurar NetworkPolicies con selectors específicos para evitar fugas.
• Cold starts: Los pods efímeros tienen un overhead de arranque. En clusters con CRI-O + Kata Containers, el tiempo de inicio puede llegar a 2.5 segundos (vs. 0.8s en runtimes tradicionales). Esto impacta en latencias de APIs sensibles.

Detalles técnicos

Límites del sandboxing tradicional en Kubernetes

El sandboxing en Kubernetes se basa en:

1. Runtimes livianos: gVisor (usermode kernel), Kata Containers (lightweight VMs) o Nabla Containers.
2. Aislamiento de pods: Namespaces de Linux (PID, network, IPC, UTS) y cgroups v2.
3. Control de acceso: RBAC, PodSecurityAdmission (PSA) y policies OPA/Gatekeeper.

Sin embargo, estos mecanismos no cubren casos de uso críticos para agentes de IA:

• Acceso a storage persistente: Un PVC montado en /home/user/.cache o /data puede ser modificado por un agente sin romper el sandbox.
• Permisos en APIs internas: Si el agente tiene un ServiceAccount con permisos para llamar a /apis/apps/v1, puede escalar privilegios si el sandbox se rompe.
• Comunicación entre pods: Sidecars como Istio o Linkerd añaden capas de seguridad, pero también aumentan la superficie de ataque (ej: CVE-2026-22222 en Istio 1.20).

agent-substrate: el modelo efímero y escalable

• Agentes como actores: Se definen como CRDs (ActorTemplate), no como pods. Ejemplo:

  apiVersion: substrate.io/v1alpha1
  kind: ActorTemplate
  metadata:
    name: code-review-agent
  spec:
    runtime: gVisor
    command: ["python", "/agent/main.py"]
    env:
    - name: MAX_RUNTIME
      value: "300"  # 5 minutos de timeout
  

• Worker pools compartidos: En lugar de un pod por agente, se usan pools de workers efímeros que ejecutan actores bajo demanda. Los workers se crean con templates reutilizables y se destruyen al terminar.
• Suspensión y reanudación: Los actores pueden ser pausados (agent-substrate pause <actor-id>) y reanudados cuando se necesiten, liberando recursos.

• Reducción de overhead: En pruebas con 1000 actores inactivos, agent-substrate reduce el uso de CPU del plano de control en un 60% vs. Kubernetes estándar (datos de la CNCF, julio 2026).
• Escalabilidad horizontal: Los workers se escalan con HPA basado en métricas de cola de actores. Ejemplo de configuración:

  apiVersion: autoscaling/v2
  kind: HorizontalPodAutoscaler
  metadata:
    name: worker-pool-hpa
  spec:
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: worker-pool
    minReplicas: 2
    maxReplicas: 50
    metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  

• Compatibilidad con runtimes: Funciona con gVisor, Kata Containers y Nabla, pero requiere ajustes en el CRI. Por ejemplo, en CRI-O, se debe configurar:

  [plugins."io.containerd.grpc.v1.cri"]
    sandbox_image = "gcr.io/k8s-staging-sandboxes/pause:3.9"
    disable_hugetlb_controller = true  # Recomendado para agent-substrate
  

agent-sandbox: sandboxing avanzado en Kubernetes

• Sandbox CRD: Define un pod con runtimes específicos y políticas de seguridad.

  apiVersion: sandboxes.k8s.io/v1alpha1
  kind: Sandbox
  metadata:
    name: secure-agent
  spec:
    runtimeClassName: kata-containers
    securityContext:
      seccompProfile:
        type: RuntimeDefault
      runAsNonRoot: true
    volumes:
    - name: cache
      emptyDir: {}
  

• Controlador de lifecycle: Gestiona la creación, destrucción y rotación de sandboxes.
• Integración con CSI: Para montar almacenamiento efímero y evitar fugas de datos.

• No resuelve el problema de pods dedicados: Sigue requiriendo un pod por agente, aunque sea más seguro.
• Overhead en clusters grandes: Cada sandbox añade un pod al plano de control, lo que puede saturar etcd en clusters con >2000 pods.

Qué deberían hacer los administradores y equipos técnicos

1. Auditar permisos de agentes existentes

kubectl auth can-i --as=system:serviceaccount:ai-agents:code-review-agent --list

Si el resultado incluye cluster-admin o permisos en secrets, restringir con RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: ai-agents
  name: code-review-role
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["get", "list"]
- apiGroups: ["batch"]
  resources: ["jobs"]
  verbs: ["create"]

2. Implementar agent-substrate para flotas dinámicas

1. Instalar agent-substrate en el cluster (requiere Kubernetes 1.27+):

   kubectl apply -f https://github.com/substrate-io/agent-substrate/releases/download/v0.3.0/install.yaml
   

1. Definir ActorTemplates para los agentes (ej: uno por skill, no por instancia):

   apiVersion: substrate.io/v1alpha1
   kind: ActorTemplate
   metadata:
     name: data-analysis
   spec:
     runtime: gVisor
     resources:
       requests:
         cpu: "100m"
         memory: "256Mi"
       limits:
         cpu: "500m"
         memory: "1Gi"
   

1. Configurar un pool de workers compartidos:

   kubectl apply -f pool-worker.yaml  # Ejemplo en docs de agent-substrate
   

1. Reemplazar los despliegues existentes por actores efímeros. Usar kubectl substrate invoke para probar:

   kubectl substrate invoke data-analysis --input '{"query": "SELECT * FROM logs"}'
   

3. Fortalecer el sandboxing con políticas adicionales

• Habilitar PodSecurityAdmission (PSA) en modo enforce:

  apiVersion: v1
  kind: Namespace
  metadata:
    name: ai-agents
    labels:
      pod-security.kubernetes.io/enforce: baseline
      pod-security.kubernetes.io/enforce-version: v1.28
  

• Usar seccomp y AppArmor: Definir perfiles estrictos para agentes. Ejemplo para gVisor:

  securityContext:
    seccompProfile:
      type: Localhost
      localhostProfile: "runtime/default.json"
  

• Aislar storage persistente: Usar emptyDir con sizeLimit o PVCs efímeros:

  volumes:
  - name: scratch
    emptyDir:
      sizeLimit: 1Gi
  

4. Monitorear y alertar sobre comportamientos anómalos

• Audit2Log: Usar el plugin de audit de Kubernetes para registrar acciones de agentes:

  apiVersion: audit.k8s.io/v1
  kind: Policy
  rules:
  - level: RequestResponse
    resources:
    - group: "substrate.io"
      resources: ["actors"]
  

• Prometheus metrics: Exponer métricas de agent-substrate para alertar sobre:

– Fallos en runtimes (agent_substrate_runtime_errors_total).

increase(agent_substrate_actor_errors_total[5m]) > 0

5. Planificar la migración a modelos efímeros

1. Fase 1 (0-3 meses): Auditar agentes existentes y aplicar RBAC estricto.
2. Fase 2 (3-6 meses): Implementar agent-substrate para nuevos agentes o de baja criticidad.
3. Fase 3 (6-12 meses): Migrar agentes críticos a modelos efímeros, usando agent-sandbox + agent-substrate en conjunto.
4. Fase 4 (12+ meses): Evaluar alternativas como Kubernetes Workload Identity para agentes con identidades dinámicas.

Conclusión

El sandboxing es un primer paso necesario, pero no suficiente para agentes de IA en Kubernetes. La eficiencia operativa y la escalabilidad requieren un cambio de modelo: de pods dedicados a actores efímeros y pools compartidos. Proyectos como agent-substrate demuestran que es posible combinar seguridad, aislamiento y escalabilidad, pero su adopción requiere ajustes en permisos, monitoreo y arquitectura.

Para equipos de DevOps, la prioridad es auditar permisos hoy y probar agent-substrate en entornos de staging. Para equipos de seguridad, el foco debe estar en restringir accesos a APIs internas y aislar storage persistente. El futuro no es solo «agentes seguros», sino agentes que escalan de forma económica y sostenible.

Fuentes

• CNCF: Why sandboxing your agent is not enough (julio 2026)
• Kubernetes Blog: PodSecurityAdmission en Kubernetes 1.28
• agent-substrate: Documentación técnica (v0.3.0)
• agent-sandbox: CRD y controlador (SIG Apps)
• CVE Details: Vulnerabilidades en runtimes de sandboxing (2026)