---
type: "post"
id: "build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640"
slug: "build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640"
title: "Build WhatsApp AI agents with Amazon Bedrock AgentCore"
description: "AWS describes SMART, an open-source Python SDK and Terraform stack for connecting agents on Amazon Bedrock AgentCore to WhatsApp."
retrieval_nugget: "AWS describes SMART, an open-source Python SDK and Terraform stack for connecting agents on Amazon Bedrock AgentCore to WhatsApp. It packages channel plumbing—webhooks, media, memory, scheduling, and message templates—around an agent developers still own, offering a concrete starting point for teams building conversational products."
published_at: "2026-11-18"
updated_at: "2026-11-18"
record_date: "2026-11-18"
date_kind: "published_at"
topics: ["agents","enterprise-agents"]
entities: ["Amazon Web Services","Amazon Bedrock AgentCore","SMART","WhatsApp","Meta","Strands Agents","LangGraph","Pydantic-AI"]
related_patterns: ["agent-ready-software-exposes-capabilities"]
novelty_label: "new_fact"
what_changed: "The story adds a WhatsApp deployment toolkit for building AI agents with Amazon Bedrock AgentCore."
prior_refs: ["https://newruntime.com/posts/building-an-ai-powered-contract-intelligence-platform-with-7ab3d6/","https://newruntime.com/posts/build-a-semantic-layer-for-agentic-ai-on-b577b3/","https://newruntime.com/posts/build-a-semantic-layer-for-agentic-ai-on-ec1cc0/","https://newruntime.com/posts/build-a-multi-agent-music-production-pipeline-on-481b51/"]
source_url: "https://aws.amazon.com/blogs/machine-learning/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore"
source_urls: ["https://aws.amazon.com/blogs/machine-learning/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640/","markdown":"https://newruntime.com/posts/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640.md","json":"https://newruntime.com/posts/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640.json"}
markdown_url: "https://newruntime.com/posts/build-whatsapp-ai-agents-with-amazon-bedrock-agentcore-32c640.md"
---

# Build WhatsApp AI agents with Amazon Bedrock AgentCore

## Retrieval answer

AWS describes SMART, an open-source Python SDK and Terraform stack for connecting agents on Amazon Bedrock AgentCore to WhatsApp. It packages channel plumbing—webhooks, media, memory, scheduling, and message templates—around an agent developers still own, offering a concrete starting point for teams building conversational products.

## Summary

AWS describes SMART, an open-source Python SDK and Terraform stack for connecting agents on Amazon Bedrock AgentCore to WhatsApp. It packages channel plumbing—webhooks, media, memory, scheduling, and message templates—around an agent developers still own, offering a concrete starting point for teams building conversational products.

## What happened

AWS’s announcement introduces SMART (Social Messaging Agent Runtime Toolkit), a toolkit comprising a Python SDK and Terraform stack. A developer supplies an agent running on Amazon Bedrock AgentCore; SMART handles the WhatsApp channel layer. AWS says one command deploys the infrastructure into the developer’s AWS account. The toolkit is framework-agnostic: the announcement describes automatic memory wiring for Strands Agents and integration options for LangGraph, Pydantic-AI, or another framework that controls its conversation loop.

The integration covers inbound webhook signature verification and payload normalization, media processing, conversation memory, scheduled messages, and outbound triggers from external systems. AWS says voice notes go through Amazon Transcribe; other media can be represented as descriptors or handled through a registered hook. AgentCore memory is scoped to each phone number, and retention defaults to seven days. The announcement also describes per-user rate limiting, defaulting to 20 messages per minute when the DynamoDB state table is enabled, and readable responses for throttling or agent failures. A guardrail resource is configured by default, but teams can use the default, supply their own, or opt out through an environment setting.

A `socialagent init` command scaffolds projects from three blueprints: `minimal`, `personal-assistant`, and `appointment-scheduler`. Developers can run `socialagent dev` locally without deploying infrastructure; the real model call still requires AWS credentials and Bedrock access for blueprints beyond minimal. AWS cautions that this local environment does not simulate IAM or Meta template review, and recommends testing through a deployed stack before considering the work complete.

Deployment uses Terraform under the hood and provisions AgentCore runtime and memory, Lambda functions, SNS ingestion, an event API, EventBridge Scheduler, S3 buckets, and CloudWatch dashboards and alarms, among other resources. The announcement says Docker is not required locally because the agent image and Lambda layer build in AWS CodeBuild. A WhatsApp Business Account must be linked to the created SNS topic separately; otherwise, AWS says inbound messages go nowhere without an error. Messages sent more than 24 hours after a user’s last message require a pre-approved Meta template. The post calls the code sample non-production and advises teams to work with security and legal teams before deployment.

## What the archive adds

New Runtime’s earlier coverage described AgentCore examples for contract intelligence, a multi-agent music pipeline, and governed analytics. The [contract-intelligence note](https://newruntime.com/posts/building-an-ai-powered-contract-intelligence-platform-with-7ab3d6/) (September 30, 2026) focused on division of labor between agents and analytics; the [music-pipeline note](https://newruntime.com/posts/build-a-multi-agent-music-production-pipeline-on-481b51/) (September 30, 2026) described shared runtime infrastructure; and the [semantic-layer note](https://newruntime.com/posts/build-a-semantic-layer-for-agentic-ai-on-b577b3/) (October 22, 2026) examined governed access to analytics. SMART is a new event in that continuing AgentCore thread, with a distinct focus on messaging-channel infrastructure.

## Trend signal

This supports [agent-ready software exposes capabilities](https://newruntime.com/patterns/agent-ready-software-exposes-capabilities/): SMART presents a compact contract in which the agent receives an inbound message and returns text or attachments, while the toolkit handles channel operations. The boundary is useful because channel access, scheduling, and memory can be composed without embedding all their wiring in the agent’s business logic. The announcement does not establish how widely this design will be adopted beyond the described use cases.

## Why now

AWS frames WhatsApp as a significant customer interface in Latin America, India, and Southeast Asia, while describing channel integration as a burden that can consume a product roadmap. The toolkit responds to that specific operational friction by bundling several services and WhatsApp behaviors into a deployable stack. AWS also reports that Webmotors, in a separate deployment, moved from a planned two-month engagement to six weeks and controlled production ahead of full launch.

## Connections to other events

The new toolkit connects to the earlier AgentCore examples in New Runtime’s [contract-intelligence coverage](https://newruntime.com/posts/building-an-ai-powered-contract-intelligence-platform-with-7ab3d6/) and [multi-agent music-pipeline coverage](https://newruntime.com/posts/build-a-multi-agent-music-production-pipeline-on-481b51/): all place application-specific agent logic on AgentCore while relying on surrounding infrastructure for operational needs. SMART’s distinguishing layer is the WhatsApp interaction path rather than document analysis or collaboration among agents.

## Why it matters

For a team building a messaging agent, much of the work is not the model call. It is maintaining reliable delivery, dealing with different message payloads and media, managing conversation state, and honoring platform rules. SMART offers a way to start from those recurring integration concerns rather than rebuilding each one. Its narrow agent contract may also make it easier to change the model or framework without rewriting the channel layer.

That convenience is not the same as production readiness. The deployment touches identity, user data, media storage, external triggers, and outbound messaging. The sample’s non-production warning matters: teams still need to review permissions, retention, compliance, failure handling, and Meta’s template process in their own environment. The framework is most valuable as a reference implementation and acceleration layer, not as a substitute for operational ownership.

## What happens next

- **AWS will document or release further SMART examples covering production hardening and deployment trade-offs** (6 months, 55%). Watch for: repository updates that expand the security, compliance, and operations guidance.

## Limits and uncertainty

AWS presents SMART as sample code and explicitly says it is for non-production usage. The announcement describes an existing Webmotors deployment and a six-week delivery timeline, but does not provide independent validation, comparative build costs, reliability measurements, or evidence of broader adoption. It also leaves production safeguards and compliance decisions to each team. Developers should verify the repository’s current implementation, regional service availability, model access, and Meta requirements before relying on the described workflow.

## Skill to build now

Map one real WhatsApp conversation from inbound webhook through agent response and any scheduled follow-up. Identify where user identity, message state, media, and template approval enter that path. Then use SMART’s local development loop to exercise the agent behavior before provisioning cloud resources, while treating its stubbed channel I/O as a fast iteration aid—not as a test of IAM, Meta approval, or deployed delivery.

## Reader takeaway

SMART turns WhatsApp integration into a reusable channel layer around an AgentCore agent, including memory, media, scheduling, and templates. It can shorten the path to a working prototype, but the AWS announcement itself labels the sample non-production: teams must still validate security, compliance, and real deployed behavior before launch.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Agents](https://newruntime.com/topics/agents.md): Explore the agents topic hub.
- topic hub: [Enterprise Agents](https://newruntime.com/topics/enterprise-agents.md): Explore the enterprise-agents topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
