AgentChat: Conversational Operations on WhatsApp

Agentic WhatsApp chat built on Bedrock and AgentCore that not only talks but acts: agents run real operations through a secure MCP server over company APIs, scaling customer care for FinTech & Retail.

Comment

Inspiration

WhatsApp is 24/7. Most business operations are not. A customer who writes on a Sunday evening, at the moment of highest purchase intent, often gets an answer on Monday morning, 14 hours later. Every unanswered message is a sale that goes cold, while advisors spend their day repeating the same answers to frequently asked questions instead of selling.

And a wrong answer in regulated industries like financial services is not just a mistake, it is a risk. We wanted an assistant that could serve, sell and hand off to a human, without ever saying anything that is not in the company's official documentation.

What it does

An agentic WhatsApp assistant that delivers fast, secure and scalable customer care in natural language:

  • Serves: answers questions using only curated, official company documentation, citing the source.
  • Sells: quotes products (e.g. life and auto insurance) directly in the chat and registers every prospect together with their quote.
  • Hands off: when a conversation needs a person, it escalates to a human advisor in Amazon Connect, with the context already registered.
  • Understands text, voice notes and images: customers can write, send an audio or share a photo.
  • Remembers: keeps conversation context so customers never repeat themselves.
  • Same agent, different knowledge base: swapping the curated knowledge and tools adapts the assistant to banking (loans and installment calculator), tourism (destination information and trip quotes) or insurance (policies and quotes).

The business sets the rules, not the model.

How we built it

A 100% serverless architecture on AWS:

  1. Channel: AWS End User Messaging Social receives WhatsApp messages (text, audio, image) and publishes them to Amazon SNS. A Lambda trigger stores media in Amazon S3 and invokes the orchestrator.
  2. Orchestration: a chatOrchestrator Lambda loads each use case's configuration from Amazon DynamoDB and invokes the agent.
  3. Agent runtime: Amazon Bedrock AgentCore Runtime runs the agent, with AgentCore Memory for conversation context and AgentCore Identity & Observability managed by the platform.
  4. Guardrails: Amazon Bedrock Guardrails filter inputs and outputs, and a grounding check verifies each answer against the retrieved content before it reaches the customer.
  5. Knowledge: Amazon Bedrock Knowledge Bases with Amazon S3 documents, Amazon Titan Embeddings v2 and Amazon S3 Vectors. The agent only answers with what it retrieves and cites the source.
  6. Models: Amazon Nova Lite for conversation, Voxtral for voice notes and a vision model for images. The agent chooses the model for each input.
  7. Agent tools: consultar_kb (RAG with source citation), cotizar_seguro (life and auto quotes) and derivar_asesor (handoff to a person). Leads and quotes are stored in DynamoDB.
  8. Human handoff: escalations are registered and picked up by an advisor in Amazon Connect.

The journey of a message: WhatsApp → End User Messaging → SNS → orchestration → AgentCore Runtime → input guardrails → memory → decide (answer, quote, register or hand off) → grounding check → reply on WhatsApp or handoff to Amazon Connect.

Challenges we ran into

  • Trust: in financial services a wrong answer is a risk. We built three layers of trust: what the agent knows (only curated, official information), what it can say (input and output guardrails) and when it must escalate (handoff to a person).
  • Multimodal input over WhatsApp: customers send voice notes and images, not just text, so each input type is routed to the right model.
  • Conversation continuity: WhatsApp chats are asynchronous and often interrupted, so context lives in AgentCore Memory.
  • Reusability: the solution had to work for banking, tourism and insurance without rebuilding the agent, so behavior is driven by configuration and knowledge, not hard-coded logic.
  • Deployment speed: we designed it to be deployed inside the customer's own AWS account, with data that never leaves their environment.

Accomplishments that we're proud of

  • 620 thousand interactions per month handled without growing the team at the same pace.
  • 100% of prospects registered with their quote.
  • 100% of answers based on official documentation.
  • Zero unanswered prospects: 24/7 responses in seconds.
  • A solution ready to deploy in less than a week in the customer's AWS account.

What we learned

  • Trust is designed in layers: curated knowledge, guardrails and human escalation work together.
  • Grounding every answer in official documentation matters more than model size.
  • Managed and serverless services (End User Messaging, Bedrock, AgentCore, S3 Vectors) let a small team focus on business value instead of infrastructure.
  • The same agent can serve very different industries when the knowledge base and the tools change.

What's next for the project

  • Expand to more verticals, with more tools and operations per industry.
  • Richer agent actions beyond quoting, such as managing customer operations through business APIs.
  • Deeper observability and automated evaluation of agent quality.

Built With

  • agentic-ai
  • ai-agents
  • amazon-api-gateway
  • amazon-bedrock
  • amazon-bedrock-agentcore
  • amazon-bedrock-guardrails
  • amazon-cloudwatch
  • amazon-dynamodb
  • aws-end-user-messaging
  • aws-iam
  • aws-lambda
  • generative-ai
  • model-context-protocol-(mcp)
  • python
  • rest
  • whatsapp-business-platform
Share this project:

Updates

Submission history