En el último año hemos visto un crecimiento acelerado en la construcción de agentes de IA: aplicaciones que no solo responden a un prompt, sino que también razonan, planean acciones, invocan herramientas externas y aprenden de sus resultados. Llevar un agente desde la etapa de prototipo hasta producción requiere infraestructura confiable, observabilidad y controles para operar de manera segura y a escala.

Aquí es donde entra Amazon Bedrock AgentCore.

¿Qué es Amazon Bedrock AgentCore?

Amazon Bedrock AgentCore es un servicio que permite desplegar y operar agentes de IA de forma segura y escalable. Ofrece:

  • Infraestructura optimizada para cargas dinámicas de agentes.
  • Integración flexible con frameworks como Strands Agents, LangGraph, LlamaIndex o CrewAI.
  • Compatibilidad con cualquier modelo fundacional, dentro o fuera de Amazon Bedrock.
  • Controles de operación y observabilidad listos para producción.

En pocas palabras, elimina el heavy lifting de crear la infraestructura de agentes desde cero, para que los equipos puedan enfocarse en la lógica de negocio y acelerar el paso a producción.

Actualmente, AgentCore se encuentra en preview, por lo que conviene esperar para despliegues críticos en producción — pero es un momento ideal para explorar sus capacidades y prepararse.

Ajustando nuestro agente para AgentCore Runtime

En un post anterior construimos un agente utilizando Strands Agents. Ahora vamos a integrarlo con AgentCore Runtime para desplegarlo.

Primero, instalamos las librerías necesarias:

pip install bedrock-agentcore strands-agents strands-agents-tools

Haremos tres modificaciones clave en el agente existente:

1. Importar el runtime de Bedrock:

from bedrock_agentcore.runtime import BedrockAgentCoreApp

2. Inicializar la aplicación de AgentCore:

app = BedrockAgentCoreApp()

3. Definir un entrypoint para procesar las solicitudes:

@app.entrypoint
def invoke(payload: dict):
    """Process user input and return a response"""
    user_message = payload.get("prompt")
    result = agent(user_message)
    return {"result": result.message}


if __name__ == "__main__":
    app.run()

Con esto, nuestro agente queda listo para ejecutarse dentro de AgentCore. Este es el código completo:

from strands import Agent, tool
from strands_tools import calculator, current_time
import requests
from datetime import datetime
from bedrock_agentcore.runtime import BedrockAgentCoreApp

app = BedrockAgentCoreApp()


@tool
def tipo_cambio_sunat() -> dict:
    """
    Obtiene el tipo de cambio del día de hoy desde SUNAT.

    Returns:
        dict: Diccionario con fecha, tipo de cambio compra y venta
              Ejemplo: {"fecha": "29/09/2025", "compra": 3.494, "venta": 3.502}
    """
    try:
        url = "https://www.sunat.gob.pe/a/txt/tipoCambio.txt"
        response = requests.get(url, timeout=10)
        response.raise_for_status()

        data = response.text.strip()
        parts = data.split('|')

        if len(parts) < 3:
            raise ValueError("Formato de respuesta inesperado de SUNAT")

        return {
            "fecha": parts[0],
            "compra": float(parts[1]),
            "venta": float(parts[2]),
            "moneda": "USD/PEN"
        }

    except requests.RequestException as e:
        return {"error": f"Error al conectar con SUNAT: {str(e)}"}
    except (ValueError, IndexError) as e:
        return {"error": f"Error al procesar datos de SUNAT: {str(e)}"}
    except Exception as e:
        return {"error": f"Error inesperado: {str(e)}"}


# Crea un agente con nuestra tool y tools de la comunidad
agent = Agent(tools=[calculator, current_time, tipo_cambio_sunat])


@app.entrypoint
def invoke(payload: dict):
    """Process user input and return a response"""
    user_message = payload.get("prompt")
    result = agent(user_message)
    return {"result": result.message}


if __name__ == "__main__":
    app.run()

Probando localmente

Antes de desplegar en la nube, podemos verificarlo de forma local:

python mi_agente.py

El servicio se expondrá en el puerto 8080. Le enviamos un prompt de prueba con curl:

curl -X POST http://localhost:8080/invocations \
  -H "Content-Type: application/json" \
  -d '{"prompt": "¿Cuál es el tipo de cambio de hoy según SUNAT? Y si tengo 100 dólares, ¿cuántos soles serían al tipo de cambio de venta?"}'

La respuesta confirma que el agente sigue funcionando correctamente bajo AgentCore:

{
  "result": {
    "role": "assistant",
    "content": [{
      "text": "Según SUNAT, el tipo de cambio de hoy 29/09/2025 es:\n- Compra: S/ 3.494 por dólar\n- Venta: S/ 3.502 por dólar\n\nSi tienes 100 dólares y los cambias al tipo de cambio de venta, obtendrías: S/ 350.20 soles."
    }]
  }
}

Realizando el despliegue

Vamos a usar el starter toolkit de Amazon Bedrock AgentCore. Lo instalamos con pip:

pip install bedrock-agentcore-starter-toolkit

Creamos un archivo requirements.txt con nuestras dependencias:

strands-agents
bedrock-agentcore
strands-agents-tools

Configuramos el agente con el siguiente comando (puedes dar enter en todas las preguntas para usar la configuración por defecto):

agentcore configure -e mi_agente.py

Procedemos a desplegar el agente:

agentcore launch

Una vez desplegado, lo probamos:

agentcore invoke '{"prompt": "¿Cuál es el tipo de cambio de hoy según SUNAT? Y si tengo 100 dólares, ¿cuántos soles serían al tipo de cambio de venta?"}'

Visualizando el agente en la consola

Ingresamos al servicio Amazon Bedrock AgentCore, seleccionamos la opción Agent Runtime y hacemos clic en nuestro agente. En la página de detalle veremos un ejemplo de cómo invocarlo, y ahí mismo se muestra el ARN del runtime que necesitamos copiar para usar en nuestro código.

Interactuando con el agente desde una UI

Para probar nuestro agente de forma rápida, creamos una pequeña aplicación con Streamlit que nos da una interfaz de chat.

Primero instalamos Streamlit:

pip install streamlit

Creamos un archivo llamado basic-chat-streamlit.py:

import json
import time
import uuid

import boto3
import streamlit as st

# Cliente de Bedrock AgentCore
agent_core = boto3.client("bedrock-agentcore", region_name="us-east-1")

# Generar un session_id válido (≥ 33 caracteres)
session_id = str(int(time.time())) + "_" + uuid.uuid4().hex

st.title("Chat básico con Bedrock AgentCore")
st.write("Ejemplo: Streamlit + AgentCore Runtime + Strands Agents")

# ARN del runtime desplegado en AgentCore
RUNTIME_ARN = "arn:aws:bedrock-agentcore:us-east-1:123456789012:runtime/mi_agente-xxxxxxxxxx"

# Caja de input estilo chat
if prompt := st.chat_input("Escribe tu mensaje..."):
    st.chat_message("user").write(prompt)

    with st.spinner("Consultando al agente..."):
        # Invocamos el runtime
        response = agent_core.invoke_agent_runtime(
            agentRuntimeArn=RUNTIME_ARN,
            runtimeSessionId=session_id,
            payload=json.dumps({"prompt": prompt}),
            qualifier="DEFAULT",
        )

        # Parsear respuesta
        result = json.loads(response["response"].read())

        # Mostrar respuesta del agente
        st.chat_message("assistant").write(result["result"]["content"][0]["text"])

Importante: actualiza la región y el RUNTIME_ARN con los valores de tu propio agente.

Para ejecutar la aplicación:

streamlit run basic-chat-streamlit.py

Esto abrirá una interfaz web sencilla donde podrás escribir mensajes y ver las respuestas de tu agente como un chat.

Componentes clave de Amazon Bedrock AgentCore

Más allá del runtime que ya usamos en el ejemplo, Amazon Bedrock AgentCore trae varios componentes adicionales que facilitan la construcción y operación de agentes en un entorno empresarial.

AgentCore Runtime

La capa base que da un entorno de ejecución seguro y serverless para correr el código del agente o de sus herramientas. Soporta tanto interacciones en tiempo real con baja latencia como cargas asíncronas que pueden correr hasta 8 horas. Cada sesión está completamente aislada para mantener la separación de datos, y funciona con frameworks open source, modelos y cargas multimodales.

AgentCore Memory

Permite manejar memoria de corto y largo plazo para que los agentes sean context aware. El desarrollador decide qué recordar mientras el servicio se encarga de toda la infraestructura de memoria. Así, los agentes aprenden de interacciones pasadas y traen el contexto adecuado a la conversación.

AgentCore Identity

Un sistema de identidad y acceso diseñado para agentes. Les permite autenticarse de forma segura y acceder a recursos o herramientas. Se integra con proveedores de identidad como Amazon Cognito, Microsoft Entra ID o Okta, y habilita acceso a recursos de AWS o servicios externos bajo consentimiento del usuario o políticas pre-aprobadas.

AgentCore Gateway

El puente para que los agentes descubran y usen herramientas. Convierte fácilmente APIs existentes, Lambdas o servicios en tools compatibles con agentes. Esto les abre la puerta a ejecutar tareas reales en entornos complejos sin fricción.

AgentCore Code Interpreter

Un entorno aislado y seguro para ejecutar código. Soporta varios lenguajes (Python, JavaScript, TypeScript) y permite que el agente haga análisis de datos o automatización de flujos con aislamiento a nivel de VM como capa de seguridad.

AgentCore Browser Tool

Un navegador en la nube que los agentes pueden usar para interactuar con páginas web: desde navegar y llenar formularios hasta ejecutar flujos más complejos. Es model-agnostic y está pensado para escalar.

AgentCore Observability

Toda la visibilidad necesaria para producción: logs, métricas y trazas. Se apoya en Amazon CloudWatch con dashboards listos y compatibilidad con OpenTelemetry para integrarlo a tus tableros existentes.

Conclusión

Amazon Bedrock AgentCore es una pieza clave para pasar de un agente experimental a uno preparado para producción. Aunque todavía está en preview, ofrece una arquitectura pensada para la operación real de agentes: runtime administrado, observabilidad integrada y compatibilidad con cualquier framework o modelo.

Si ya estás experimentando con frameworks como Strands Agents o quieres entender el protocolo estándar para agentes interoperables como MCP, AgentCore es el siguiente paso lógico para preparar tu stack de agentes para la nube.

Cómo lo aplicamos en Caleidos

En clientes con cargas reales, AgentCore se vuelve la plataforma sobre la que se operan agentes en producción 24×7: orquestación entre agentes, memoria persistente, integración con identidad corporativa, observabilidad completa. Es lo que separa un demo bonito de una solución que el negocio puede confiar para procesos críticos.

Caleidos diseña e implementa estos despliegues como parte de nuestro servicio Agentic AI con AWS, incluyendo arquitectura sobre AgentCore, integración con Strands Agents y MCP, evaluación de calidad y operación continua con Caleidos Lens©.

¿Tienes un agente en prototipo y quieres llevarlo a producción? Hablemos →