Conversational Agents
Developers evaluating whether a conversational workload fits their use case, or looking for the right entry point into building a chat agent on AgentCore. If you've already decided and want to start coding, jump to the Quick Start or Harness Quick Start.
Conversational agents that engage humans in real-time across various messaging platforms with multi-turn memory, enterprise identity, and streaming. Agents can respond to human-initiated messages or proactively initiate conversations. AgentCore handles the platform complexity so you focus on the agent's intelligence.
What Is It?
A conversational agent is an AI that interacts directly with humans through natural language. The user input is received by the agent, which reasons and responds, optionally calling tools along the way. Input channels include chat interfaces, messaging platforms (Slack, WhatsApp, email, Teams), phone/voice systems (SMS, RCS), and custom UIs. Unlike traditional chatbots with scripted flows, conversational agents on AgentCore use LLM reasoning to handle open-ended queries, maintain context across turns, and take actions on behalf of the user. See How AgentCore Runtime works for the underlying execution model.
Common Use Cases
- Customer support / helpdesk — End-users ask questions about their account, orders, or services. The agent retrieves information, executes actions (refunds, resets), and escalates to humans when needed. Guardrails are critical here since the agent is customer-facing.
- Internal knowledge assistant — Employees ask HR, IT, or policy questions. The agent searches internal knowledge bases and answers with auth-scoped, role-appropriate responses. Different answers for ICs vs. managers based on propagated user permissions.
- Sales co-pilot / deal desk — Sales reps get real-time guidance during customer calls. The agent pulls CRM data, pricing rules, and competitive intel on demand. Actions require human confirmation before execution since the rep makes the final decision.
- NL-to-SQL / self-serve analytics — Business users ask questions in plain English. The agent translates to SQL, runs the query, and returns results with charts or summaries.
- Onboarding concierge — New customers or employees are guided through multi-step setup processes with personalized, context-aware assistance.
- Technical troubleshooting — Developers or IT staff describe issues. The agent correlates logs, suggests fixes, and can execute diagnostic commands.
- Voice agents — Phone or voice-first interactions (IVR replacement, contact center, accessibility). The agent receives audio input, reasons over the transcript, and responds with synthesized speech.
- Proactive customer notifications — The agent initiates a conversation when a business event occurs (flight delay, shipping exception, appointment reminder, payment due). It contacts the customer via the optimal channel (SMS, RCS, WhatsApp, or email) based on preference, cost, and deliverability — then handles follow-up questions, rebooking, or issue resolution in a multi-turn exchange. Where the traditional approach sends a one-way notification, the agent turns it into a customer-satisfying interaction.
- Outbound marketing engagement — The agent reaches out to customers with personalized offers via messaging channels. The customer can ask questions, browse products, and complete purchases within the conversation — no app switch required. Example: a retailer welcomes new customers with a promotional offer via RCS, then assists with product selection and checkout.
- Multi-channel journey orchestration — A single conversational agent manages customer interactions that span SMS, RCS, WhatsApp, email, and web chat. The agent autonomously selects the optimal channel for each message and maintains full conversation context across channel switches. An engagement database tracks channel preferences, resolution rates, and conversation analytics.
- Inbound email triage and response — A Bedrock agent automatically categorizes, prioritizes, and routes incoming customer emails, then drafts or sends intelligent responses. For most enterprises, inbound email remains the highest-volume customer channel — agentic triage turns a queue-and-wait process into an AI-resolved interaction.
When to Choose Conversational
Choose this workload when:
- A human is the primary trigger (they type a message)
- A business event triggers proactive communications to contact a human (e.g., a flight delay, order update, or promotional offer that becomes a multi-turn exchange)
- The agent needs to respond in real-time with token-by-token streaming
- Multi-turn conversation state matters (the agent should remember what was said)
- The agent acts on behalf of a specific user with their identity and permissions
- The primary output is natural language directed at a human
- The conversations span across multiple messaging platforms (web chat, SMS, RCS, WhatsApp, email)
For a side-by-side comparison with Workflow and Coding patterns, see the Workloads overview comparison table.
Strengths and Design Considerations
| Strengths | Design Considerations |
|---|---|
| Real-time streaming for responsive UX | Plan for per-session cost; use scale-to-zero and session timeouts to manage spend |
| Multi-turn memory with session + long-term recall | Long conversations need context window strategies (summarization, truncation) |
| End-user identity propagation (zero-trust) | Requires IdP integration (Entra ID, Okta, Cognito) — plan this early |
| Natural fit for human-facing applications | Human-facing surface needs input guardrails (content filters, prompt boundaries) |
| Rich UI feedback (typing indicators, tool activity) | Session affinity means scaling per user; size infrastructure accordingly |
AgentCore Configuration Summary
| Purpose | Description | AgentCore capability |
|---|---|---|
| User authentication | End-user OAuth bearer tokens (Entra ID, Okta, Cognito) so the agent acts on behalf of the user | Identity |
| Conversation context | Session memory + long-term recall, namespaced per user for multi-turn continuity and cross-session personalization | Memory |
| Execution environment | Streaming-enabled runtime with session affinity and up to 8h lifecycle ¹ for real-time, stateful conversations | Runtime |
| Input safety | Content filters, topic boundaries, and PII redaction to protect against adversarial or off-topic inputs | Guardrails |
| Quality measurement | Builtin.GoalSuccessRate, Builtin.Helpfulness, and Builtin.Correctness evaluations, used alongside deterministic tests, to catch regressions before users feel them | Evaluations |
| Debugging and tracing | Per-conversation traces with user context to diagnose "the agent gave me wrong info" | Observability |
| Tool access | User-scoped API access with auth propagation so the agent calls external services as the user | Gateway |
¹ Session duration is architecture guidance based on typical AgentCore usage patterns. Verify current limits in the AgentCore service quotas.
Context Sources
Agent context extends well beyond session memory. A production conversational agent typically draws from multiple sources to ground its responses:
| Source | Purpose | AgentCore integration |
|---|---|---|
| Session memory | What was said in this conversation | Memory (short-term) |
| Long-term memory | Cross-session recall, user preferences, past interactions | Memory (long-term) |
| Knowledge bases | Structured documentation, FAQs, policy documents | Bedrock Knowledge Bases via Gateway |
| Web search | Real-time information the agent's training data doesn't cover | Tool via Gateway |
| User profile / CRM | Who the user is, their history, entitlements | Tool via Gateway with identity propagation |
| System state | Current status of orders, tickets, infrastructure | Tool via Gateway |
Human-in-the-Loop and Confirmation
Not every action should execute without human approval. Conversational agents support several confirmation patterns:
- Explicit confirmation — The agent describes what it will do and waits for the user to say "yes." Required for high-risk actions (refunds, account changes, data deletion).
- Passive confirmation — The agent previews the result ("Here's the email I'd send...") and the user can edit or approve before it goes out.
- Escalation — The agent recognizes it cannot confidently handle the request and hands off to a human operator with full conversation context.
Use Bedrock Guardrails for deterministic controls (topic denial, PII redaction) and AgentCore Policy (Cedar) for tool-level access decisions. Guardrails are probabilistic (content scoring); Cedar policies are deterministic (allow/deny). Use both: Cedar to prevent the agent from calling a tool it shouldn't, guardrails to filter what the model says.
Optimizing Cost, Latency, and Accuracy
Every conversational agent navigates a three-way tradeoff:
- Cost — Larger models and longer context windows cost more per token. Frequent tool calls add latency and API costs.
- Latency — Users expect sub-second first-token times. Model size, context length, and tool call chains all add latency.
- Accuracy — More context and larger models improve quality, but at the cost of the other two dimensions.
Practical techniques to manage this triangle:
- Use scale-to-zero to eliminate idle costs
- Route simple queries to smaller/faster models; escalate complex ones to larger models
- Apply context window strategies (summarization, truncation) to keep costs predictable without losing conversational coherence
- Use AgentCore Evaluations to measure quality over time, catching regressions before they reach users
- Track per-agent costs with application inference profiles for attribution and budgeting
When Not to Use This Pattern
Skip the Conversational pattern when:
- There is no human in the loop. If an event (alert, webhook, file upload) triggers the agent and results go to a downstream system, the Workflow pattern is a better fit — it is designed for machine-to-machine automation and costs less at scale.
- The task produces code or structured file artifacts. Use the Coding pattern instead.
- Interaction is single-turn and stateless. A simple API call to an LLM (with no memory or session state) is often enough — an AWS Lambda function calling the Bedrock InvokeModel API may be all you need, without the overhead of a persistent agent runtime.
- You cannot integrate an identity provider. This pattern depends on user identity propagation (OAuth bearer tokens). If your deployment has no IdP, consider the Workflow pattern with service credentials. If you have Amazon Cognito, see the Identity getting started with Cognito tutorial.
Start Building
The Conversational Agent Catalog is the primary starting point for conversational agent development. It contains maintained samples with identity, memory, and streaming built in.
Scaffold a conversational project from your terminal:
The commands below were checked with AgentCore CLI 0.26.0. Run agentcore create --help and agentcore add memory --help when using a different CLI version.
# Create a harness with memory for multi-turn conversations
agentcore create --name mychatagent --model-provider bedrock
agentcore add memory --name chatmemory --strategies SEMANTIC,SUMMARIZATION
# Test locally (deploys and opens browser test page)
agentcore dev
Or choose a sample that matches your use case:
| Use Case | Sample | Key Capability |
|---|---|---|
| General conversational AI | Conversational Starter | Identity + Memory + Streaming |
| Auth-scoped helpdesk | Customer Support Assistant (VPC) | VPC-secured, customer identity propagation |
| Operations collaboration (A2A) | SRE/A2A Incident Response | Multi-agent, operations triage |
| Browser/Evaluations/Optimization | Market Trends Agent | Browser use, data gathering, evaluation loops |
Customer Stories
| Customer | What They Built | Key Metric |
|---|---|---|
| BGL | Slack-based NL-to-SQL agent for self-serve BI | 200+ employees self-serve instantly |
| Iberdrola | Multi-agent IT operations with LangGraph + VPC-secured runtime | Reduced resolution time |
| Thomson Reuters | Central orchestrator routing to specialized service agents with HITL | Enterprise-scale multi-domain support |
Further Reading
- Well-Architected Agentic AI Lens — cognitive pipeline optimization, tool reliability, agent observability
- Agentic AI security best practices — identity propagation, input validation, tool safety
- Memory-augmented agents — architectural patterns for agent memory (AWS Prescriptive Guidance)
- Deploy Strands agents to AgentCore — code-first deployment guide for the Strands framework
Next Steps
Quick Start →
Choose the right conversational sample and understand action risks.
Harness Quick Start →
The config-only path: managed agent loop with built-in per-user memory.
Architecture Guidance →
Identity, memory, runtime, gateway, and guardrails deep dive.
Session Management →
Sessions, context windows, streaming, and multi-tenant isolation.
Patterns & Architecture →
Reference architecture and recommended multi-agent patterns.
Everything produced by the samples and commands on this page is a prototype until you have applied the controls in Preparing for production. Do not use a prototype endpoint to serve real user traffic.