AWS Bedrock AgentCore Runtime suma shells interactivos para depuración en tiempo real

Introducción

Hasta ahora, interactuar con agentes de IA alojados en AWS Bedrock requería ejecutar comandos de forma asincrónica mediante el API InvokeAgentRuntimeCommand. Esto limitaba la capacidad de depurar problemas en tiempo real, inspeccionar archivos, o ejecutar comandos ad-hoc dentro del entorno aislado de un coding agent como Claude Code o OpenAI Codex. La solución típica implicaba exponer un puerto SSH, montar volúmenes NFS, o usar herramientas externas de logging, lo que aumentaba la superficie de ataque y complejizaba la configuración.

Con la introducción de shells interactivos en Amazon Bedrock AgentCore Runtime, los equipos de DevOps ahora pueden abrir un terminal persistente (PTY-backed) directamente dentro de la microVM que aloja al agente, usando un nuevo endpoint WebSocket. Esto no solo elimina la necesidad de configurar accesos remotos, sino que también permite mantener el estado de la sesión (variables de entorno, directorios de trabajo, historial de comandos) entre reconexiones.

Qué ocurrió

AWS anunció el 18 de junio de 2026 el lanzamiento de interactive shells en AgentCore Runtime, integrado al conjunto de herramientas para agentes de Bedrock. La nueva funcionalidad se basa en dos componentes clave:

1. Nuevo API InvokeAgentRuntimeCommandShell: Expone un socket WebSocket persistente que permite abrir una terminal interactiva dentro de la microVM del agente.
2. Integración con microVMs aisladas: Cada shell se ejecuta en un entorno aislado, con colores, autocompletado, soporte para Ctrl+C, y redimensionado de terminal.

Hasta este cambio, los desarrolladores solo podían ejecutar comandos de forma puntual mediante InvokeAgentRuntimeCommand. Ahora, con el nuevo API, se puede:

• Autenticarse en la microVM del agente.
• Inspeccionar archivos y directorios en tiempo real.
• Ejecutar comandos ad-hoc para debuggear el estado del entorno.
• Mantener múltiples shells concurrentes (hasta 10 por runtime) para trabajar en diferentes ramas o tareas en paralelo.

Para interactuar con el nuevo shell, se usa el comando CLI de AgentCore:

agentcore exec --it --runtime <runtime-arn>

Esto abre una sesión interactiva con autocompletado, historial de comandos y reconexión automática ante caídas de red breves.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps y SRE

• Reducción de tiempo de depuración: Pasar de comandos asincrónicos a un terminal interactivo acelera la resolución de problemas en entornos remotos. Por ejemplo, si un coding agent falla al compilar, en lugar de ejecutar múltiples comandos puntuales, se puede abrir una shell, revisar logs en /var/log/, y ajustar configuraciones sobre la marcha.
• Eliminación de puertos SSH expuestos: Las microVMs de Bedrock ya están aisladas, pero antes requerían configuraciones adicionales para acceder a ellas. Ahora, el terminal se abre directamente sobre WebSocket, sin necesidad de exponer puertos 22.
• Soporte para CI/CD: Los equipos pueden integrar shells interactivos en pipelines para:

– Ejecutar pruebas de integración en el mismo contexto que el agente.

– Depurar fallos en despliegues sin acceder manualmente a la instancia.

Para equipos de Seguridad

• Superficie de ataque reducida: Al eliminar la necesidad de SSH, se reduce la exposición de puertos y la complejidad en la configuración de firewalls. El tráfico de terminales ahora fluye por WebSocket, que puede ser auditado y limitado mediante políticas IAM.
• Aislamiento mejorado: Cada shell se ejecuta en una microVM con sus propias políticas de seguridad, sin compartir estado con otros agentes o sesiones.
• Autenticación integrada: El acceso a los shells requiere credenciales IAM válidas, y las sesiones pueden ser auditadas mediante CloudTrail.

Para Cloud Architects

• Escalabilidad: Cada runtime de AgentCore soporta hasta 10 shells concurrentes, permitiendo a equipos trabajar en múltiples ramas o tareas en paralelo sin solapamientos.
• Costos: Las microVMs son efímeras, por lo que el uso de shells interactivos no implica costos adicionales significativos (solo el tiempo de CPU mientras la sesión está activa).

Detalles técnicos

Arquitectura del nuevo shell interactivo

El flujo de trabajo para abrir un shell interactivo es el siguiente:

1. Autenticación: El cliente (CLI de AgentCore o SDK) se autentica con AWS IAM y obtiene un token JWT.
2. Negociación WebSocket: Se establece una conexión persistente mediante el endpoint wss://agentcore.runtime.<region>.amazonaws.com usando el token.
3. Inicialización de PTY: AgentCore Runtime crea un pseudo-terminal (PTY) dentro de la microVM del agente, con soporte para:

– Manejo de señales: Soporte para Ctrl+C (SIGINT), Ctrl+Z (SIGTSTP), etc.

– Redimensionado de terminal: El cliente envía eventos de resize para ajustar el tamaño del PTY.

1. Persistencia de estado: La sesión mantiene:

– Directorio de trabajo actual.

– Historial de comandos (vía ~/.bash_history o equivalente).

1. Reconexión: Si la conexión se cae:

– Desconexiones largas: El usuario puede reiniciar la sesión manualmente con los mismos IDs.

Comandos clave del nuevo API

Las microVMs de AgentCore Runtime están basadas en Firecracker, el mismo hipervisor usado por AWS Lambda. Cada shell interactivo:

• Se ejecuta en un contexto aislado (pid, mount, network).
• Tiene acceso limitado a recursos (CPU, memoria, red) según las políticas de IAM.
• No comparte estado con otros shells o agentes.

Limitaciones conocidas

• Soporte de shells: Solo se garantiza para terminales basados en Linux (no Windows).
• Número de shells: Hasta 10 concurrentes por runtime. Superar este límite devuelve un error 429 Too Many Requests.
• Duración de la sesión: Las microVMs son efímeras. Si la sesión queda inactiva por más de 60 minutos, se fuerza el cierre.

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

1. Actualizar AgentCore Runtime

Verificar que el entorno de Bedrock esté actualizado a la versión AgentCore Runtime 2.1.0 o superior (lanzada el 18/06/2026). Para actualizar:

# Usando AWS CLI
aws bedrock-agentcore update-agent-runtime \
    --runtime-arn <runtime-arn> \
    --agent-alias <alias> \
    --runtime-version "2.1.0"

2. Configurar políticas IAM

Asegurarse de que los roles IAM tengan permisos para:

• bedrock-agentcore:InvokeAgentRuntimeCommandShell
• bedrock-agentcore:GetAgentRuntimeShell
• bedrock-agentcore:ListAgentRuntimeShells

Ejemplo de política mínima:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock-agentcore:InvokeAgentRuntimeCommandShell",
        "bedrock-agentcore:GetAgentRuntimeShell"
      ],
      "Resource": "arn:aws:bedrock:<region>:<account>:agent-runtime/<runtime-id>"
    }
  ]
}

3. Probar el nuevo shell interactivo

Usar el CLI de AgentCore para abrir una sesión:

# Instalar el CLI (si no está disponible)
pip install aws-bedrock-agentcore-cli

# Abrir shell interactivo
agentcore exec --it --runtime <runtime-arn>

Dentro del shell, probar:

• Ejecutar comandos: ls -la, cat /etc/os-release.
• Verificar variables de entorno: echo $PATH.
• Probar autocompletado (debería funcionar con Tab).
• Simular una caída de red: cerrar la terminal abruptamente y reconectarse con el mismo session_id y shell_id.

4. Integrar en pipelines de CI/CD

Para equipos que usan GitHub Actions, GitLab CI, o AWS CodePipeline:

# Ejemplo para GitHub Actions
name: Debug coding agent
on: [push]

jobs:
  debug-agent:
    runs-on: ubuntu-latest
    steps:
      - name: Open interactive shell in Bedrock
        uses: aws-actions/bedrock-agentcore-cli@v1
        with:
          runtime-arn: "arn:aws:bedrock:us-east-1:123456789012:agent-runtime/abc123"
          command: |
            ls -la /workspace
            echo "Debugging agent..."
            tail -n 50 /var/log/agent.log

5. Monitorear y auditar

Configurar CloudWatch para rastrear:

• Sesiones activas (ListAgentRuntimeShells).
• Comandos ejecutados en cada shell (hasta 100 últimos comandos por sesión).
• Eventos de reconexión/desconexión.

# Configurar logging para shells
aws logs put-metric-filter \
    --log-group-name "/aws/bedrock/agentcore/shells" \
    --filter-name "ShellCommands" \
    --filter-pattern "{ $.eventType = \"CommandExecuted\" }" \
    --metric-transformations \
        metricName=CommandCount,metricNamespace=BedrockShells,metricValue=1

Conclusión

La introducción de shells interactivos en Amazon Bedrock AgentCore Runtime marca un salto cualitativo para equipos que dependen de coding agents en entornos aislados. Ya no es necesario exponer puertos SSH, configurar VPNs, o usar herramientas externas de logging para depurar problemas en tiempo real. Con sesiones persistentes, reconexión automática y soporte para autocompletado, los desarrolladores pueden interactuar con sus agentes como si estuvieran en una terminal local, mientras mantienen el aislamiento y seguridad de las microVMs.

Para equipos de DevOps y SRE, esto significa:

• Menor tiempo de resolución de incidentes.
• Integración nativa en flujos de CI/CD.
• Reducción de la superficie de ataque al eliminar accesos remotos innecesarios.

La implementación es directa: actualizar a AgentCore Runtime 2.1.0+, configurar políticas IAM, y empezar a usar el comando agentcore exec --it. El único límite práctico es el de 10 shells concurrentes por runtime, que debería ser suficiente para la mayoría de los casos de uso.

FIN