Deploy a Fast‑Fashion E‑Commerce AI Agent in Days to Handle Millions of Concurrent Queries

AgentCore Runtime Overview

AgentCore Runtime packages an AI agent or tool as a Docker image, pushes it to Amazon ECR and runs it in a server‑less microVM environment. Each request is executed in an isolated microVM, providing on‑demand resource allocation, automatic horizontal scaling and session isolation.

Supported protocols

HTTP (REST) – simple request/response.

MCP (Model Context Protocol) – enables tools and agents to share model context.

A2A (Agent‑to‑Agent) – open standard for inter‑agent communication and discovery.

Typical usage patterns

HTTP synchronous

Example: size‑recommendation assistant returns a size suggestion within one second.

HTTP asynchronous

Example: AI‑generated outfit catalog returns a job ID while image generation runs for 30 s–1 min.

HTTP streaming

Example: real‑time text chat streams tokens to the client.

WebSocket

Example: voice‑guided shopping allows the user to interrupt the agent mid‑sentence.

Deployment workflow

[ Write A2A Server code ]
   ⬇
[ Run A2A Server locally (JSON‑RPC/9000) ]
   ⬇
[ Build Docker image and push to ECR ]
   ⬇
[ Deploy with AgentCore CLI to Bedrock Runtime ]
   ⬇
[ Generate Agent Card and expose endpoint ]

Minimal Python example using the strands SDK:

from strands import Agent, tool
from bedrock_agentcore.runtime import BedrockAgentCoreApp

app = BedrockAgentCoreApp()

@tool
def check_inventory(product_id: str):
    return {"product_id": product_id, "stock": 150, "warehouse": "华东仓"}

@app.entrypoint
def fashion_ecommerce_agent(payload):
    user_input = payload.get("prompt")
    response = agent(user_input)
    return response.message["content"][0]["text"]

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

Session isolation and lifecycle

Each user session receives a unique runtimeSessionId and runs in its own microVM. Session states are Active , Idle and Terminated . The /ping endpoint reports health (e.g., Healthy or HealthyBusy) and automatically terminates a session after 15 minutes of inactivity.

Invocation example:

response = agent_core_client.InvokeAgentRuntime(
    agentRuntimeArn=agent_arn,
    runtimeSessionId="customer-123456-session-123456789",
    payload=json.dumps({"prompt": "这款碎花连衣裙有什么颜色可选？"}).encode()
)

Asynchronous tasks

Functions decorated with @app.async_task return immediately while the task runs in the background. The session state switches to HealthyBusy until completion.

@app.async_task
async def sync_inventory_from_supplier():
    await asyncio.sleep(30)  # Simulate long‑running sync
    return "库存同步完成"

AgentCore Memory

Memory provides short‑term (per‑session) and long‑term (persistent) storage. Built‑in strategies include:

Semantic Memory (vector‑based retrieval)

User Preference Memory

Summary Memory

Custom Memory

Creating a memory resource with user‑preference and semantic strategies:

client = MemoryClient(region_name=REGION)
memory = client.create_memory_and_wait(
    name="FastFashionAgentMemory",
    strategies=[
        {StrategyType.USER_PREFERENCE.value: {"name": "CustomerFashionPreferences",
                                            "namespaces": ["fashion/customer/{actorId}/preferences"]}},
        {StrategyType.SEMANTIC.value: {"name": "CustomerFashionSemantic",
                                        "namespaces": ["fashion/customer/{actorId}/semantic"]}}
    ],
    description="快时尚电商客服智能体的记忆存储",
    event_expiry_days=90
)

A MemoryHookProvider automatically loads recent dialogue history on agent initialization and saves new user‑assistant exchanges after each turn.

Memory branching for multi‑agent systems

Multiple specialized agents (e.g., Shopping Coordinator, Style Recommendation, Order & Logistics) can share the same memory_id and session_id while using distinct branch_name values, isolating their context similarly to Git branches.

MCP server example

from mcp.server.fastmcp import FastMCP
from starlette.responses import JSONResponse

mcp = FastMCP(host="0.0.0.0", stateless_http=True)

@mcp.tool()
def calculate_discount(original_price: float, discount_rate: float) -> float:
    """计算商品折扣后的价格"""
    return original_price * (1 - discount_rate)

@mcp.tool()
def check_size_availability(product_id: str, size: str) -> dict:
    """查询指定商品特定尺码的库存情况"""
    return {"product_id": product_id, "size": size, "available": True, "quantity": 25}

if __name__ == "__main__":
    mcp.run(transport="streamable-http")

A2A server requirements

Container exposes 0.0.0.0:9000.

Root path / implements JSON‑RPC 2.0.

Standard Agent Card available at /.well-known/agent-card.json.

Supports OAuth2 or SigV4 authentication.

Versioning and endpoints

Each AgentCore Runtime instance is immutable‑versioned. The initial deployment creates version V1; subsequent updates create new immutable versions, each containing the full configuration required for execution.

Agent lifecycle hooks

Hooks such as AgentInitializedEvent and MessageAddedEvent can be used to load recent memory and store new messages.

class MemoryHookProvider(HookProvider):
    def __init__(self, memory_client: MemoryClient, memory_id: str):
        self.memory_client = memory_client
        self.memory_id = memory_id

    def on_agent_initialized(self, event: AgentInitializedEvent):
        # Load recent turns from memory and inject into system prompt
        ...

    def on_message_added(self, event: MessageAddedEvent):
        # Persist user and assistant messages to memory
        ...

    def register_hooks(self, registry: HookRegistry):
        registry.add_callback(MessageAddedEvent, self.on_message_added)
        registry.add_callback(AgentInitializedEvent, self.on_agent_initialized)

Conclusion

AgentCore Runtime enables fast, secure, and horizontally scalable deployment of AI agents for fast‑fashion e‑commerce scenarios, providing isolated microVM sessions, asynchronous processing, and a unified memory service that supports both short‑term context and long‑term knowledge retention.