AWS Loom: gobernanza de agentes IA a escala con identidad y seguridad integrada en AWS

Introducción

Los equipos de plataforma que escalan agentes de IA en entornos empresariales enfrentan problemas recurrentes: cómo garantizar que cada agente opere con los permisos correctos, evitar que los tokens de identidad se pierdan en la cadena de delegación y controlar el crecimiento desordenado de agentes sin sacrificar la productividad. AWS respondió a estos desafíos con Loom, una plataforma de referencia open source lanzada en julio de 2026 que muestra cómo construir, desplegar y gobernar agentes de IA sobre AWS con controles de seguridad integrados desde el diseño. Loom no es un servicio administrado, sino un blueprint operativo que las organizaciones pueden adaptar o replicar internamente.

La plataforma se construye sobre dos componentes clave de AWS:

• Strands Agents SDK (versión 1.4.0 en el lanzamiento): un SDK en Python para construir agentes con memoria, herramientas y flujos de trabajo.
• Bedrock AgentCore Runtime (GA desde abril de 2026): el motor de ejecución de agentes de Amazon Bedrock, que ahora soporta RFC 8693 para intercambio de tokens de identidad en cadenas de delegación.

Loom aborda siete problemas críticos en escalado de agentes, desde etiquetado consistente de recursos hasta revisión humana obligatoria para acciones sensibles. Su enfoque se diferencia de soluciones genéricas al integrar identidad, gobernanza y observabilidad en un mismo flujo, sin requerir cambios en el código de los agentes en tiempo de ejecución.

Qué ocurrió

El 20 de julio de 2026, AWS anunció en su blog de open source la disponibilidad de Loom, una plataforma de referencia alojada en AWS Labs. El proyecto surgió de un prototipo interno documentado por Heeki Park, arquitecto de soluciones principal en AWS, en un artículo de Medium publicado en junio de 2026. Park detalló allí cómo Loom resuelve problemas como:

• Propagación de identidad en cadenas de delegación: cuando un agente actúa en nombre de un usuario y este agente invoca un servidor MCP, que a su vez consume una API REST, cada «salto» (hop) debe conservar los permisos originales del usuario.
• Gestión del sprawl de agentes: evitar que decenas de agentes descontrolados consuman recursos o accedan a datos sensibles sin supervisión.
• Revisión humana obligatoria: pausar ejecuciones sensibles para aprobación manual, integrando mecanismos nativos en Strands Agents y MCP.

Loom implementa RFC 8693 (Token Exchange for OAuth 2.0) para validar tokens en cada salto de la cadena de delegación. Esto permite que:

1. El usuario original conserve su identidad en todos los tokens downstream.
2. Los sistemas finales (como API Gateway o servidores MCP) reciban tokens con los permisos estrictamente necesarios.
3. La visualización de la cadena de delegación sea transparente en una UI unificada.

El modelo de despliegue de Loom es estático: los agentes se despliegan a partir de un template en Python preescrito (basado en Strands Agents), donde solo se inyectan configuraciones como guías de comportamiento, recursos de memoria o conexiones MCP. Esto elimina riesgos de generación de código en runtime y permite que el código del agente sea escaneado una sola vez por los equipos de seguridad antes de desplegarlo en múltiples entornos.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps e Infraestructura

Loom introduce cambios en cómo se gestionan plantillas de despliegue, identidad en tiempo de ejecución y gobernanza de recursos. Los equipos deberán:

• Adaptar sus pipelines para incluir validación de etiquetas obligatorias (loom:application, loom:group, loom:owner) en todos los recursos desplegados. Esto afecta a Terraform, CloudFormation y otros Infrastructure as Code (IaC) actuales.
• Revisar políticas IAM para soportar RFC 8693. Por ejemplo, si un agente invoca una Lambda, la política debe permitir el intercambio de tokens con sts:AssumeRoleWithWebIdentity y no solo lambda:InvokeFunction.
• Configurar AgentCore Runtime para que los tokens downstream incluyan los scopes correctos. En pruebas internas de AWS, se reportó que el 30% de los fallos en cadenas de delegación se debían a scopes mal configurados en los tokens iniciales.

Para equipos de Seguridad

Loom implementa controles que reducen el blast radius de agentes maliciosos o configurados incorrectamente:

• Secretos nunca almacenados en Loom: se recuperan dinámicamente de AWS Secrets Manager solo cuando son necesarios, con autenticación gestionada por AgentCore Identity.
• Revisión humana obligatoria: antes de ejecutar acciones sensibles (como eliminar datos o modificar configuraciones críticas), Loom pausa la ejecución y requiere aprobación. Esto se implementa mediante el framework de hooks de Strands Agents y MCP elicitations.
• Etiquetado forzoso: los recursos sin las tres etiquetas obligatorias (loom:application, loom:group, loom:owner) son rechazados en el despliegue. AWS reportó que en pruebas con clientes, el 22% de los recursos creados manualmente carecían de estas etiquetas, lo que Loom bloqueó automáticamente.

Para equipos de Cloud

Loom depende de servicios en GA o preview pública:

• Bedrock AgentCore Runtime (GA desde abril de 2026).
• AWS Agent Registry (preview pública): los agentes deben ser publicados allí antes de ser usados en producción. Actualmente, el ARN del registro usa un string aleatorio en lugar del nombre del registro, lo que obliga a usar wildcards en políticas IAM (arn:aws:bedrock:*:*:agent-registry/*).
• OpenTelemetry: Loom inyecta métricas y traces en cada agente desplegado, permitiendo correlacionar logs entre el agente, los servidores MCP y las APIs invocadas.

Detalles técnicos

Arquitectura de Loom

Loom sigue un modelo de despliegue estático con tres capas:

1. Agente preescrito: un template en Python basado en Strands Agents (versión 1.4.0). El código nunca cambia entre despliegues; solo se modifican parámetros como:

– memory_resources: configuración de memoria y persistencia.

– mcp_servers: servidores externos invocados por el agente.

– Ejemplo de configuración:

     # config/agent.yaml
     agent:
       name: "finance-assistant"
       guidelines:
         - "No reveles información financiera confidencial."
         - "Solicita confirmación para transacciones > $1000."
       memory_resources:
         type: "dynamodb"
         table_name: "loom-memory-finance-assistant"
       mcp_servers:
         - name: "banking-mcp"
           endpoint: "https://mcp-banking.example.com"
     

1. Bedrock AgentCore Runtime: ejecuta el agente en un entorno aislado. AgentCore soporta RFC 8693 para intercambio de tokens, permitiendo que la identidad del usuario original se propague a través de la cadena de delegación.

1. UI y API unificada: incluye:

– Interfaz de chat: para usuarios finales, limitada a los agentes en su grupo y a su historial de conversaciones.

– API de gobernanza: para integrar con pipelines de CI/CD (por ejemplo, validar que un agente cumpla con políticas antes de desplegarlo).

Mecanismos de seguridad integrados

• Agent Registry: Los agentes deben ser publicados allí antes de uso en producción. Actualmente, el ARN del registro es de la forma arn:aws:bedrock:us-east-1:123456789012:agent-registry/abc123, lo que obliga a políticas IAM como:

  {
    "Effect": "Allow",
    "Action": "bedrock:GetAgent",
    "Resource": "arn:aws:bedrock:*:*:agent-registry/*"
  }
  

• OpenTelemetry: Loom inyecta traces en cada agente, permitiendo correlacionar:

– Tiempos de respuesta de servidores MCP.

– Llamadas a APIs externas.

Ejemplo de exportación de métricas:

  export OTEL_EXPORTER=otlp
  export OTEL_EXPORTER_ENDPOINT=http://collector:4318
  

Limitaciones conocidas

• No soporta generación dinámica de código: los agentes deben ser desplegados a partir de un template estático. Esto implica que para modificar el comportamiento de un agente, se debe actualizar el template y redeployarlo.
• Agent Registry en preview: la integración con el registro aún está en preview pública, con cambios frecuentes en el formato de ARN y políticas IAM.
• Dependencia de AWS: Loom está diseñado para AWS y no es portable a otros clouds sin adaptaciones significativas.

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

1. Evaluar la preparación del entorno

Antes de desplegar Loom, los equipos deben garantizar:

• Bedrock AgentCore Runtime esté en versión 1.2 o superior (GA desde abril de 2026).
• Strands Agents SDK esté actualizado a 1.4.0 o superior.
• AWS Secrets Manager esté configurado con políticas de rotación de credenciales automática (recomendación: cada 90 días).
• IAM tenga políticas para soportar RFC 8693:

  # Ejemplo de política IAM para agentes que invocan Lambdas
  {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": "sts:AssumeRoleWithWebIdentity",
        "Resource": "arn:aws:iam::*:oidc-provider/bedrock.amazonaws.com/*"
      },
      {
        "Effect": "Allow",
        "Action": "lambda:InvokeFunction",
        "Resource": "arn:aws:lambda:*:*:function:agent-*"
      }
    ]
  }
  

2. Configurar el entorno de Loom

1. Clonar el repositorio:

   git clone https://github.com/awslabs/loom.git
   cd loom
   

1. Instalar dependencias:

   python -m venv venv
   source venv/bin/activate
   pip install -r requirements.txt
   

1. Configurar AWS CLI con permisos de administrador para Bedrock y Secrets Manager:

   aws configure set region us-east-1
   aws configure set output json
   

3. Desplegar un agente de ejemplo

Loom incluye un template de ejemplo (examples/simple-agent). Para desplegarlo:

1. Crear un secret en AWS Secrets Manager con las credenciales necesarias para el agente:

   aws secretsmanager create-secret \
     --name "loom/simple-agent/api-key" \
     --secret-string '{"key": "sk-1234567890"}'
   

1. Configurar el agente en config/agent.yaml:

   agent:
     name: "simple-chat"
     guidelines:
       - "Responde preguntas técnicas de AWS."
     memory_resources:
       type: "dynamodb"
       table_name: "loom-memory-simple-chat"
     mcp_servers:
       - name: "aws-info-mcp"
         endpoint: "https://mcp-aws-info.example.com"
   

1. Desplegar:

   python -m loom.cli deploy \
     --agent-config config/agent.yaml \
     --tags '{"loom:application": "demo", "loom:group": "dev", "loom:owner": "platform-team"}'
   

4. Validar el despliegue

1. Verificar etiquetas:

   aws dynamodb list-tables --query 'TableNames[?contains(@, `loom-memory-simple-chat`)]'
   aws resourcegroupstaggingapi get-resources \
     --tag-filters Key=loom:application,Values=demo
   

1. Probar el agente:

   python -m loom.cli chat \
     --agent-name simple-chat \
     --message "¿Cómo configuro OpenTelemetry en Loom?"
   

1. Revisar logs en OpenTelemetry:

   kubectl port-forward svc/otel-collector 4318:4318
   curl http://localhost:4318/v1/traces
   

5. Integrar con pipelines de CI/CD

Para evitar despliegues manuales, Loom puede ser integrado en pipelines:

• Validación de etiquetas: usar un step en GitHub Actions o GitLab CI que verifique que todos los recursos desplegados tengan las etiquetas obligatorias.
• Escaneo de código: integrar un linter como loom-validate para revisar que los templates cumplan con políticas de seguridad antes de desplegar.

  # .github/workflows/validate-loom.yml
  name: Validar agente Loom
  on: [push]
  jobs:
    validate:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v4
        - name: Instalar Loom
          run: pip install git+https://github.com/awslabs/loom.git
        - name: Validar etiquetas
          run: |
            loom validate --tags '{"loom:application": "demo"}'
        - name: Escanear código
          run: |
            loom lint config/agent.yaml
  

6. Monitorear y auditar

Loom expone métricas en OpenTelemetry que pueden ser consumidas por herramientas como Prometheus o Grafana. Configurar:

# config/otel-collector.yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:

exporters:
  prometheus:
    endpoint: "0.0.0.0:8889"

service:
  pipelines:
    metrics:
      receivers: [otlp]
      exporters: [prometheus]

Conclusión

AWS Loom es un blueprint operativo que aborda problemas concretos en la gobernanza de agentes de IA a escala: identidad propagada en cadenas de delegación, gobernanza mediante etiquetado forzoso y control de sprawl con revisión humana obligatoria. Su enfoque de despliegue estático reduce riesgos de generación de código en runtime, mientras que su integración con Strands Agents y Bedrock AgentCore Runtime lo hace compatible con flujos de trabajo existentes en AWS.

Para equipos que ya usan AWS y Strands Agents, Loom puede ser adoptado gradualmente:

1. Evaluar compatibilidad con versiones actuales de Strands Agents (1.4.0+) y Bedrock AgentCore Runtime (1.2+).
2. Configurar políticas IAM para soportar RFC 8693 y Secrets Manager.
3. Adaptar pipelines de CI/CD para validar etiquetas y escanear templates antes de desplegar.
4. Implementar monitoreo con OpenTelemetry para auditar cadenas de delegación.

Loom no es una solución plug-and-play, pero su diseño como plataforma de referencia permite a los equipos de plataforma evitar reinventar la rueda en gobernanza de agentes. La pregunta no es si adoptarlo, sino cómo integrarlo con el resto de la pila de IA en AWS sin romper flujos existentes.

Fuentes

• InfoQ: AWS Releases Loom, an Open-Source Reference Platform for Governing AI Agents at Enterprise Scale
• AWS Open Source Blog: Introducing Loom (enlace no proporcionado en fuentes originales, pero referenciado en InfoQ)