Enterprise Agentic AI for Customer Support and Sales Using Amazon Bedrock AgentCore

swisscom · Telecommunications · 2025 · source Agentic: yes · promotional bias: high · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Telecom customer support and sales agents

Swisscom needed to scale enterprise AI agents for customer support and sales while preserving cross-department coordination, Swiss data protection requirements, secure identity, internal API access, memory, observability, and low-latency B2C operations.

Constraints:

• Siloed agentic solutions had to coordinate across departments.
• Swiss data protection laws required strong compliance, data sovereignty, and privacy controls.
• Agents needed secure access to internal APIs, MCP servers, A2A servers, and customer context.
• Customer-support and sales agents had to integrate with Swisscom's SAM chatbot.
• The platform needed reusable governance, observability, evaluation, and deployment primitives.

Architecture

Swisscom implemented a Bedrock AgentCore-based agent platform around Strands agents, AgentCore Runtime, Identity, Memory, VPC integration, MCP/A2A connectivity, OpenTelemetry, and Strands evaluation. Client requests enter a Strands agent with Swisscom IdP authentication; AgentCore validates and exchanges tokens, calls Bedrock foundation models, stores session memory, and reaches internal APIs through shared VPC infrastructure.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  client-request["Client request"] --> strands-agent["Strands agent"]
  strands-agent --> agentcore-runtime["AgentCore Runtime"]
  agentcore-runtime --> agentcore-identity["AgentCore Identity"]
  strands-agent --> bedrock-foundation-model["Bedrock foundation model"]
  bedrock-foundation-model --> agentcore-memory["AgentCore Memory"]
  agentcore-memory --> strands-agent
  agentcore-identity --> internal-apis-and-mcp-a2a-servers["Internal APIs and MCP A2A servers"]
  strands-agent --> internal-apis-and-mcp-a2a-servers
  internal-apis-and-mcp-a2a-servers --> sam-chatbot["SAM chatbot"]
  observability-and-evaluation["Observability and evaluation"] --> strands-agent

Components

Data flow

A client request reaches a Strands agent running on AgentCore Runtime with a Swisscom IdP token; identity validation produces downstream tool credentials, the agent invokes Bedrock and AgentCore Memory, then accesses internal APIs, MCP servers, and A2A servers inside the shared VPC.

Why this architecture

Swisscom chose AgentCore because enterprise-scale agent deployment required secure runtime hosting, identity exchange, memory, VPC access, observability, and developer velocity in one reusable platform rather than isolated departmental agents.

Models used: Amazon Bedrock · Bedrock foundation models · Amazon Bedrock AgentCore · Strands Agents · MCP · A2A · OpenTelemetry

Scale

• Swisscom is described as having estimated 2025 revenue of $19B and more than $37B market capitalization.
  “Switzerland’s leading telecommunications provider with an estimated $19B revenue (2025) and over $37B Market capitalization as of June 2025”article, stated
• The initial implementation targets two B2C use cases: personalized sales pitches and automated technical support.
  “Swisscom partnered with AWS to implement Amazon Bedrock AgentCore for two B2C cases: 1) generating personalized sales pitches, and 2) providing automated customer support”article, stated
• The agents are expected to handle thousands of requests per month each with low latency.
  “The scalability of AgentCore Runtime allows these agents to efficiently handle thousands of requests per month each, maintaining low latency while optimizing costs.”article, stated
• Development teams reached first business stakeholder demos within 3-4 weeks.
  “Development teams achieved their first business stakeholder demos within 3-4 weeks, despite having no prior experience with Strands Agents.”article, stated

Alternatives considered (roads not taken)

Build custom token exchange servers.

Rejected because: AgentCore Identity integrates with Swisscom's IdP and simplifies secure agent/tool/data-source authentication.

Keep existing LangGraph implementation for one project team.

Rejected because: The team migrated to Strands because it reduced complexity and accelerated development.

Develop agents as isolated departmental solutions.

Rejected because: Swisscom wanted shared MCP/A2A integration and a future centralized registry for discovery and reuse.

Patterns

multi-agent-orchestration (orchestration)

Swisscom uses MCP and A2A to coordinate agents and services across domains.

privacy-preserving-processing (governance)

AgentCore Identity and user separation enforce customer-scoped access under Swiss data protection requirements.

agent-memory (memory)

AgentCore Memory stores both session and long-term customer context for B2C interactions.

observability-tracing (operations)

Strands' OpenTelemetry support exports traces into Swisscom's observability infrastructure.

eval-driven-development (evaluation)

Swisscom uses Strands evaluation test cases to assemble PoC validation pipelines quickly.

Tradeoffs

Use AgentCore services for runtime, identity, and memory.

Chose Managed AgentCore primitives integrated with Swisscom's VPC and IdP. over Custom infrastructure for hosting, token exchange, and memory..

Rationale: Managed primitives let teams focus on agents while meeting security and scalability needs.

Adopt Strands Agents for developer velocity.

Chose Strands framework with tracing, evaluation, and AgentCore integration. over Maintaining all existing LangGraph implementations..

Rationale: The cited migration reduced complexity and sped development cycles.

Gotchas (what bit them)

Cross-department agents can become siloed without shared protocols.

Root cause: Each department may build its own agentic solution and integration path.

Resolution: Use MCP, A2A, and a future centralized registry to standardize communication and reuse.

Authentication is bidirectional, not just a user login.

Root cause: Agents, MCP servers, and tools must all validate incoming tokens for service requests.

Resolution: Use temporary access tokens and AgentCore Identity for inbound and outbound authentication.

Compliance must be designed as a scaling enabler.

Root cause: Swiss data protection and data sovereignty requirements constrain how customer agents can operate.

Resolution: Keep traffic private through VPC endpoints and isolate customer data in memory/access controls.

Evaluation

Swisscom combines Strands evaluation test cases, OpenTelemetry traces, stakeholder demos, and PoC validation to evaluate agent readiness.

Metrics: Business stakeholder demo time · Requests per month per agent · Latency · Trace export into observability infrastructure

Outcomes

• Swisscom integrated two B2C agents into its SAM chatbot roadmap.
• Teams reached demos in 3-4 weeks and one team migrated from LangGraph to Strands.
• The architecture provides a reference for secure enterprise-scale agent deployment.

The case describes thousands of requests per month per agent and strict latency requirements for B2C support and sales use cases.