Customer experience automation is evolving beyond traditional chatbots and rigid decision trees. Modern systems need to understand customer intent, retrieve information, interact with business applications, execute multi-step workflows, and know when to involve a human.
AWS is bringing these capabilities together with Amazon Connect Customer Agentic CX Designer (ACXD) — a visual, no-code environment for building, testing, and optimizing agentic customer experiences.
What makes ACXD interesting is its combination of two approaches:
- Deterministic workflows: For predictable business rules, validations, routing, and controlled outcomes.
- Agentic AI: For understanding natural language, reasoning through customer requests, retrieving knowledge, and coordinating multi-step interactions.
Let's explore how it works and how developers can think about building a practical customer experience with it.
1. What Is Amazon Connect Customer Agentic CX Designer?
ACXD provides a visual workspace where teams can design customer-facing applications without building every interaction from scratch.
It supports experiences that can:
- Understand customer questions and intent.
- Guide customers through structured processes.
- Retrieve answers from trusted knowledge sources.
- Connect with APIs and external business systems.
- Handle multi-step tasks.
- Apply guardrails to control AI behavior.
- Escalate conversations when human assistance is required.
The important architectural idea is that AI does not need to control every decision. Business-critical operations can remain deterministic, while AI handles flexible conversations and reasoning.
2. Understanding the Architecture
A simplified ACXD architecture looks like this:
Customer
|
v
Amazon Connect Customer
|
v
Agentic CX Designer (ACXD)
|
+----------------------------+
| |
v v
Deterministic Workflows Agentic AI
| |
v v
Business Rules Knowledge Retrieval
Validation Natural Language
Routing Multi-step Reasoning
| |
+-------------+--------------+
|
v
Data Requests / APIs
|
v
Business Applications
|
v
Customer Response
|
Human Escalation
This is a conceptual view rather than a complete deployment diagram. The actual implementation depends on the application, integrations, and customer journey.
3. Build a Practical Use Case: E-commerce Support Assistant
Imagine an online store receiving hundreds of customer requests every day.
Customers commonly ask:
- Where is my order?
- What is your return policy?
- Can I request a refund?
- How do I change my delivery address?
- Can I speak with a support representative?
A traditional chatbot might rely on fixed menus and predefined answers. An agentic experience can understand different ways of expressing the same request and coordinate the appropriate workflow.
For example:
Customer: "I ordered a laptop last week. Can you tell me when it will arrive?"
A possible interaction:
- ACXD identifies the customer's intent as order tracking.
- The application requests the required order information.
- A data request or API integration retrieves the order status.
- The application interprets the returned information.
- The customer receives a clear delivery update.
- If the request cannot be resolved, the conversation can be escalated to a human agent.
The AI handles the conversational experience, while the order system remains the source of truth.
4. Connect ACXD to Business Systems
An agentic customer experience becomes useful when it can work with real business data.
Depending on the architecture, integrations can connect the application to:
- Order management systems.
- CRM platforms.
- Customer databases.
- Inventory services.
- Payment and billing systems.
- Internal REST APIs.
- AWS Lambda functions.
For example, a Lambda function can act as an integration layer between the customer experience and an internal application. Where private resources are involved, Lambda can be configured to run inside a VPC and access permitted private services.
A simplified integration flow:
ACXD Application
|
v
Data Request / Integration
|
v
AWS Lambda or API
|
v
Internal Business System
|
v
Structured Response
|
v
ACXD Application
Keep integrations focused and apply least-privilege permissions. The customer-facing AI should not receive unrestricted access to internal systems.
5. Combine AI Flexibility with Deterministic Control
One of the most important design decisions is knowing which tasks should use AI and which should use explicit business logic.
| Requirement | Recommended approach |
|---|---|
| Understand customer intent | Agentic AI |
| Answer policy questions | Trusted knowledge retrieval |
| Check order status | API or data request |
| Validate refund eligibility | Deterministic business rules |
| Apply approval limits | Deterministic workflow |
| Route a complex issue | Defined routing logic |
| Handle an unresolved request | Human escalation |
For example, AI can understand that a customer wants a refund. However, refund eligibility should be checked against the company's actual policy and order data.
This separation makes the application more predictable, testable, and suitable for business-critical workflows.
6. Add Knowledge and Guardrails
Customer-facing AI needs reliable information and clear boundaries.
A knowledge source can provide approved information such as:
- Return and refund policies.
- Product documentation.
- Delivery information.
- Frequently asked questions.
- Troubleshooting instructions.
Guardrails help define what the application should and should not do.
Consider these practices:
- Use approved knowledge sources.
- Avoid exposing sensitive customer information.
- Validate customer identity before sensitive operations.
- Restrict access to business APIs.
- Require approval for high-impact actions.
- Escalate uncertain or unsupported requests.
- Log and review important interactions.
The objective is not simply to make an AI assistant more capable. It is to make the experience useful, controlled, and trustworthy.
7. Test Before Deployment
A visual workflow can look correct and still behave unexpectedly when customers interact with it.
ACXD provides testing capabilities to help validate applications and their underlying flows.
A practical testing strategy should cover:
Application tests
- Does the application understand common customer requests?
- Does it provide relevant responses?
- Does it handle unexpected input appropriately?
Flow tests
- Does the conversation follow the intended path?
- Are variables and state updated correctly?
- Are data requests invoked as expected?
Routing tests
- Are customer requests routed to the right destination?
- Does escalation work when required?
Integration tests
- What happens when an API returns an error?
- How does the application handle missing data?
- Are timeouts and invalid responses handled safely?
Guardrail tests
- Does the application refuse unsupported requests?
- Does it protect sensitive information?
- Does it avoid taking unauthorized actions?
Use the available debugger and testing tools to investigate unexpected flow behavior before deployment.
8. Deploy and Monitor the Experience
Building an application is only one part of the lifecycle.
A sensible delivery process is:
- Design the customer journey.
- Build the application and its flows.
- Configure knowledge and integrations.
- Add guardrails and escalation paths.
- Run application and flow tests.
- Build and deploy the application.
- Connect it to the relevant Amazon Connect Customer flow.
- Monitor real interactions and improve the experience.
The Agentic CX block provides the connection point for invoking an ACXD application from an Amazon Connect Customer flow.
After deployment, review conversation history, transcripts, evaluations, analytics, guardrail activity, and flow traversal information where available.
Look for patterns such as:
- Questions the application repeatedly fails to answer.
- Workflows where customers abandon the conversation.
- Unnecessary human escalations.
- Slow or failing integrations.
- Knowledge gaps.
- Incorrect routing decisions.
Use these observations to improve the application incrementally.
9. Try the AWS Hands-On Workshop
AWS Builder Center provides a hands-on workshop titled:
Build, Test, Optimize: Hands-On with Amazon Connect Customer agentic CX designer (ACXD)
The workshop provides a prebuilt environment and ten industry scenarios. Participants can select a scenario and build, test, and deploy voice and digital customer experiences without writing application code.
It is listed as an intermediate-level, approximately four-hour workshop.
This is a useful way to explore the designer and understand its workflow before applying the concepts to a real customer support use case.
10. Availability and Useful Resources
Amazon Connect Customer Agentic CX Designer became generally available on September 2, 2026.
AWS announced availability in multiple AWS Regions, including:
- US East (N. Virginia)
- US West (Oregon)
- Canada Central
- Asia Pacific (Tokyo, Seoul, Singapore, Sydney)
- Europe (Frankfurt, London)
Always check the current AWS documentation for the latest regional availability and feature details.
Useful resources:
- ACXD documentation
- Testing ACXD applications
- Building and deploying ACXD applications
- AWS What's New announcement
- AWS Builder Center workshops
Final Thoughts
Amazon Connect Customer Agentic CX Designer represents an interesting direction for customer experience development.
Instead of choosing between traditional workflows and generative AI, teams can combine both: deterministic logic for controlled business outcomes and agentic AI for flexible customer conversations.
For developers and architects, the real opportunity is in designing the right boundaries between AI, business systems, knowledge sources, and human support.
A successful customer experience is not just one that can answer questions. It is one that can complete useful tasks reliably, protect customer data, and recognize when a human should take over.
What would you build first with ACXD — an order-tracking assistant, a technical support agent, or a customer onboarding workflow?
I'd be interested to hear your ideas in the comments.
Top comments (0)