Giving frontline agents instant, AI-powered customer insights
A next-generation utility business uses IoT-connected solar and digital services to reach hundreds of thousands of households and small businesses. As its customer base grew, support agents were spending too much time piecing together payment histories and usage data before they could help callers. Steamhaus helped design an AI-powered Agent on AWS that summarises a customer’s situation in seconds, directly inside the existing customer service portal.
- Designed a GenAI “payments history” agent using Amazon Bedrock Agents, AWS Lambda and Amazon Aurora
- Delivered an event-driven serverless backend fronted by Amazon API Gateway, Amazon CloudFront and AWS WAF
- Cut average time for agents to understand a customer’s account from minutes to seconds, supporting the goal of saving thousands of agent hours per month
- Established a secure, scalable pattern the utility can extend to other journeys such as fault diagnostics and upgrade offers
Helping agents keep pace with rapid growth
The customer operates in multiple African markets, providing pay-as-you-go solar, smartphones and other services through a single digital platform. Each interaction can involve:
- Device telemetry
- Payment plan details
- Prior support tickets
- Local tariff and regulatory information
Agents had access to this data, but it was scattered across several internal systems. As new products and territories came online, call lengths and training times increased. The company wanted a way for agents to see a clear, concise summary of a customer’s situation as soon as a call or chat started - without replacing the existing CRM or data platform.
Any solution needed to respect local connectivity constraints, keep sensitive financial data inside their AWS estate, and be easy to extend as new use cases emerged.
Co-designing a first GenAI use case with the in-house team
Steamhaus and the customer’s platform group ran a focused discovery and architecture workshop to:
- Prioritise candidate use cases (customer data summarisation, call scripts, proactive notifications)
- Select the payments-history view as the first use case with the clearest value and lowest integration risk
- Map the existing payments database, APIs and agent tools running on AWS
- Agree success measures, including reduced handling time and more consistent explanations for customers
We then worked in a joint team with platform engineers and data specialists to design a solution that could be trialled quickly but scaled into a production-grade pattern.
Bedrock Agents orchestrating summaries from live payments data
The agent backend is built as a serverless, event-driven architecture:
- Data source: Amazon Aurora - Customer payments and plan information are stored in an Aurora PostgreSQL cluster already used by the main platform.
- Business logic: AWS Lambda - A “GetPayments” Lambda function encapsulates all the SQL and domain logic needed to retrieve the right slice of data for a given customer and timeframe. This keeps private schema details out of prompts and ensures all queries go through audited, least-privilege paths.
- Reasoning layer: Amazon Bedrock Agents - A Bedrock Agent orchestrates calls to the Lambda function via the Amazon RDS Data API, then uses an Anthropic Claude model to generate natural-language summaries and recommended next questions for the agent. Tool definitions and prompts are stored as configuration and deployed via IaC.
- Orchestration: AWS Step Functions (Express) - For more complex flows (e.g. summarise, then check arrears thresholds, then flag potential upgrades), Step Functions manages the sequence of Lambda/tool calls and error handling.
- API & edge: Amazon API Gateway, Amazon CloudFront and AWS WAF - An internal API Gateway endpoint exposes the agent as a REST API to the existing agent UI. CloudFront and WAF sit in front of the public-facing parts of the platform, providing caching, TLS termination and protection against common web threats.
- Security & observability - All components run in private subnets inside a dedicated VPC. Access to Bedrock, Aurora and logs is controlled with tightly scoped IAM roles. CloudWatch metrics, logs and dashboards help the operations team track latency, error rates and usage patterns.
When an agent opens a customer record, the web app calls the agent API with a minimal set of identifiers. The Bedrock Agent invokes the payments Lambda, retrieves recent history, and composes a short briefing that highlights key patterns (e.g. “on-time payer with one recent missed instalment”). The summary is displayed alongside raw data so agents can dive deeper if needed.
From single use case to a GenAI operations pattern
The payments-history copilot provides the first concrete demonstration of how GenAI can sit safely on top of the utility’s existing data platform. Early internal testing shows strong potential to shorten calls and reduce training effort for new agents.
The next steps include:
- Adding additional tools to the Bedrock Agent for device health checks and tariff guidance
- Capturing structured feedback from agents to refine prompts and evaluation criteria
- Extending the pattern to other channels, such as in-app chat and WhatsApp, while keeping all model traffic within the AWS environment
Because the solution is built using standard AWS serverless services and Bedrock Agents configured as code, the customer can treat GenAI capabilities as just another part of their platform engineering practice - with the same rigour around security, operations and cost control.
.jpg)
.png)
