Building Scalable, Serverless Customer Support with AWS Multi-Agent AI
Key Challenges
Trusted Shops needed to automate Salesforce-based customer support requests while reducing reliance on traditional ticketing workflows. The solution had to securely handle query classification, data retrieval, business actions, and response generation across multiple AI agents without introducing the complexity of managing dedicated compute infrastructure.
Key Results
Trusted Shops established a scalable, AWS-native foundation for automated customer support using Lambda, Amazon Bedrock Agents, API Gateway, and ECR. The managed serverless architecture reduced infrastructure management overhead, enabled on-demand compute, improved operational visibility, and created a flexible foundation for expanding specialised AI agents.
Overview
For Self Service Accounts, Trusted Shops sought to create a fully automated customer help system that would lessen the effort for human support staff while offering quicker, more individualised responses. In order to minimise reliance on conventional ticketing systems, the goal architecture had to be scalable, transparent, secure, and AWS-native.
AWS Lambda, Amazon Bedrock Agents, Amazon API Gateway, Amazon ECR, Amazon S3, and Amazon CloudWatch were used to construct a controlled, serverless-oriented architecture. The application and agent workflow is executed by the design using managed AWS computing resources, which eliminates the need for dedicated server infrastructure.
Figure 1. Trusted Shops multi-agent architecture and controlled support workflow.
Challenges
In order to manage incoming Salesforce requests, determine the type of customer query, extract relevant data, perform essential business operations, and offer a structured response, the client required an automated support workflow.
The architecture also needed to support the customer's long-term objective of replacing traditional ticket-based assistance with direct, structured processing on AWS. This required a modular design that supported multiple AI agents and was both scalable and operationally manageable.
From a computational perspective, the solution needed to support specific application dependencies, API connections, and the execution requirements of the agent workflow without needing unnecessary infrastructure management.
Solution
The design of the compute architecture was based on AWS managed services. Amazon API Gateway serves as the entry point for support requests, receiving JSON requests from Salesforce and forwarding them to the application layer. The application logic is implemented using AWS Lambda, packaged as a container image, and stored in Amazon ECR.
Amazon Bedrock Agents provides the regulated runtime for the multi-agent solution, and the Lambda function provides the integration layer for the agent workflow. The implementation includes four agents. After classifying the incoming request, the root agent forwards it to the proper downstream agent. The last agent returns the response to the Salesforce API after the subsequent agent retrieves information and completes necessary tasks using the predefined Knowledge Base and action groups.
Managed Compute and Containerization
AWS Lambda was used for the application integration layer since the workload is request-driven and does not require continuously operating application servers. The function was implemented using a Docker container based on the AWS Lambda Python 3.12 base image. Packing application dependencies and code into the container and keeping it in Amazon ECR creates a repeatable deployment artefact.
This approach offers the flexibility of containerised application packaging while maintaining the operational advantages of managed serverless computing. Consequently, the underlying compute hosts do not need to be managed to deploy apps and provision infrastructure.
For the agent execution layer, Amazon Bedrock Agents was used rather than developing and maintaining a separate agent runtime. Supervisor routing was set up in the root agent so that requests could be assigned to it. The root agent was configured with supervisor routing so that requests could be delegated to specialized collaborator agents. The implementation also defines the Bedrock agents and collaborators through Terraform, supporting repeatable infrastructure deployment.
Describe TCO Analysis Performed
The computational method was compared to the operational features of the Trusted Shops workload, with a focus on employing managed services to reduce the infrastructure management cost associated with dedicated compute resources. AWS Lambda was chosen for the API and agent integration workload, with container images saved in Amazon ECR, allowing compute resources to be used on demand while maintaining flexibility for application needs.
The architecture also employs Amazon Bedrock Agents as the controlled agent execution layer, eliminating the requirement to run a separate agent runtime. This mix of managed services decreased the infrastructure footprint while also aligning compute consumption with the request-driven nature of the customer-support workflow.
API Integration and Operational Management
The Lambda function was merged with the POST method of the API Gateway, which was set up as a REST API. The integration timeout was raised from the default of roughly 30 seconds to 180 seconds because the agent workflow may need more processing time than a typical API request. This made it possible for the API layer to support the anticipated agent execution flow.
For operational visibility, Amazon CloudWatch is also integrated into the design. Lambda logs and other AWS service logs are sent to CloudWatch, which offers a central location for tracking, evaluating, and resolving problems with application performance.
The AWS architecture, which includes Bedrock Agents, Knowledge Base resources, S3, Lambda functions, and an API Gateway, was defined using Terraform. lessens the need for manual configuration and enables the compute environment to be deployed consistently and often.
Business Outcome
Trusted Shops now have a controlled compute basis for automated customer service thanks to the established architecture. The Bedrock multi-agent workflow may receive incoming Salesforce queries, process them using API Gateway and Lambda, and then provide structured responses to the Salesforce API.
Utilising AWS managed compute services enables the application to access containerised dependencies through ECR while lowering the operational load of maintaining dedicated infrastructure. The system may be expanded by adding more specialised agents thanks to Bedrock Agents, which further abstracts the underlying agent execution infrastructure.
The resulting architecture provides:
- Managed, request-driven compute using AWS Lambda.
- Containerized application deployment through Amazon ECR.
- Managed multi-agent execution using Amazon Bedrock Agents.
- API-based integration through Amazon API Gateway.
- Centralized operational logging through Amazon CloudWatch.
- Repeatable infrastructure deployment through Terraform.
Conclusion
The implementation of Trusted Shops shows how to use AWS managed compute resources to create an agent solution that is both scalable and operationally controllable. While Bedrock Agents manages the multi-agent execution layer without requiring specialised agent infrastructure, Lambda and ECR offer a flexible computing and deployment base.
With the flexibility, scalability, and operational visibility needed for future expansion, this architecture gives Trusted Shops an AWS-native basis for growing automated customer care.
