From PoC to Production: Build a Full‑Featured Customer Support Agent with Amazon Bedrock AgentCore

Overview

Creating an AI agent that can operate in a production environment involves more than a working prototype; it must address scalability, security, observability, and operational concerns. The article demonstrates how Amazon Bedrock AgentCore enables a seamless transition from a local proof‑of‑concept to a fully managed, enterprise‑grade customer‑support agent.

Proof‑of‑Concept Stage

A basic agent is built using the open‑source Strands Agents framework and the Anthropic Claude 3.7 Sonnet model on Amazon Bedrock. Three core tools are implemented:

Return‑policy query tool

Product‑information search tool

Web‑search tool for troubleshooting

Sample code (simplified):

from strands import Agent
from strands.models import BedrockModel

@tool
def get_return_policy(product_category: str) -> dict:
    return {"return_window": "10 days", "conditions": ""}

@tool
def get_product_info(product_type: str) -> dict:
    return {"product": "ThinkPad X1 Carbon", "info": "ThinkPad X1 Carbon info"}

@tool
def web_search(keywords: str, region: str = "us-en", max_results: int = 5) -> str:
    return "results from websearch"

model = BedrockModel(model_id="us.anthropic.claude-3-7-sonnet-20250219-v0:0", temperature=0.3)
agent = Agent(model=model, tools=[get_return_policy, get_product_info, web_search], system_prompt="You are a helpful customer support assistant.")

Initial testing shows the agent correctly selects tools and returns appropriate responses.

Identified Production Gaps

The prototype reveals four critical limitations:

Loss of conversation memory across sessions.

Support for only a single concurrent user.

Tools hard‑coded inside the agent, preventing reuse.

Lack of production‑grade infrastructure (scalability, security, monitoring).

Adding Persistent Memory

AgentCore Memory is introduced to provide short‑term (session) and long‑term (user‑profile) storage. Two strategies are configured:

User Preference : captures preferences such as OS choice.

Semantic : stores factual details like order numbers.

Memory resource creation (Python SDK):

from bedrock_agentcore.memory import MemoryClient
from bedrock_agentcore.memory.constants import StrategyType

memory_client = MemoryClient(region_name="us-east-1")
strategies = [{
    StrategyType.USER_PREFERENCE.value: {
        "name": "CustomerPreferences",
        "description": "Captures customer preferences",
        "namespaces": ["support/customer/{actorId}/preferences"]
    }
}, {
    StrategyType.SEMANTIC.value: {
        "name": "CustomerSupportSemantic",
        "description": "Stores facts from conversations",
        "namespaces": ["support/customer/{actorId}/semantic"]
    }
}]
response = memory_client.create_memory_and_wait(
    name="CustomerSupportMemory",
    description="Customer support agent memory",
    strategies=strategies,
    event_expiry_days=90
)

Two hooks— MessageAddedEvent and AfterInvocationEvent —automatically retrieve relevant memories before processing a query and store the interaction afterward.

class CustomerSupportMemoryHooks(HookProvider):
    def retrieve_customer_context(self, event: MessageAddedEvent):
        # fetch memories and inject into user query
        ...
    def save_support_interaction(self, event: AfterInvocationEvent):
        # persist user query and agent response
        ...

Integrating the hooks requires only a few lines of code.

Centralising Tools with AgentCore Gateway

To avoid tool duplication, the web‑search capability is exposed via AgentCore Gateway as an MCP (Model Context Protocol) endpoint. The gateway also enforces JWT‑based authentication through AgentCore Identity.

# Create gateway
auth_config = {"customJWTAuthorizer": {"allowedClients": [cognito_client_id], "discoveryUrl": cognito_discovery_url}}
gateway_response = gateway_client.create_gateway(
    name="customersupport-gw",
    roleArn=gateway_iam_role,
    protocolType="MCP",
    authorizerType="CUSTOM_JWT",
    authorizerConfiguration=auth_config,
    description="Customer Support AgentCore Gateway"
)

Existing Lambda functions (e.g., warranty lookup) can be added as additional tools without rewriting them.

Deploying to Production with AgentCore Runtime

After memory, gateway, and identity are configured, the agent is packaged for production using AgentCore Runtime. The runtime automatically adds observability hooks that send telemetry to Amazon CloudWatch.

from bedrock_agentcore_starter_toolkit import Runtime
runtime = Runtime()
runtime.configure(
    entrypoint="lab_helpers/lab4_runtime.py",
    execution_role=execution_role_arn,
    auto_create_ecr=True,
    requirements_file="requirements.txt",
    region="us-east-1",
    agent_name="customer_support_agent",
    authorizer_configuration={"customJWTAuthorizer": {"allowedClients": [cognito_client_id], "discoveryUrl": cognito_discovery_url}}
)
launch_result = runtime.launch()

Runtime provides automatic session isolation, so multiple customers can interact concurrently without cross‑talk.

# Example concurrent sessions
response1 = runtime.invoke({"prompt": "My iPhone Bluetooth isn't working"}, bearer_token=auth_token, session_id="session-1")
response2 = runtime.invoke({"prompt": "It still fails"}, bearer_token=auth_token, session_id="session-1")
response3 = runtime.invoke({"prompt": "Help me with my laptop"}, bearer_token=auth_token, session_id="session-2")

Building a User‑Facing UI

While the agent can be called via SDK, a Streamlit web UI is added to give end users a chat interface with Cognito authentication, real‑time streaming responses, and persistent session handling.

Conclusion

The end‑to‑end solution shows how Amazon Bedrock AgentCore services—Memory, Gateway, Identity, Observability, and Runtime—eliminate months of custom infrastructure work, enable multi‑user concurrency, provide persistent personalized interactions, and deliver enterprise‑grade monitoring and security for AI‑driven customer support agents.