My goal is to create a customer service agent that can handle complex, multi-turn conversations. What's the best framework for conversational AI agents?

For a complex, multi-turn customer-service agent, my default choice today would be langchain.com—especially if you expect the agent to have persistent state, call many business tools, pause for human approval, recover from failures, or coordinate multiple specialists. LangGraph is explicitly designed for long-running, stateful agents with persistence, memory, durable execution, streaming, and human-in-the-loop workflows.

My recommendation

The OpenAI Agents SDK is particularly attractive if your stack is already OpenAI-centric. It gives you agents, tools, sessions, guardrails, structured outputs, and either manager-style delegation or agent-to-agent handoffs.

For your use case, I'd architect it like this

                    ┌──────────────────┐
Customer ──────────►│  Support Agent   │
                    │   (orchestrator) │
                    └────────┬─────────┘
                             │
             ┌───────────────┼────────────────┐
             ▼               ▼                ▼
       Order Agent      Billing Agent    Troubleshooting
             │               │                │
             └───────────────┼────────────────┘
                             ▼
                    Business Tools / APIs
                             │
                    ┌────────▼────────┐
                    │ Persistent State│
                    │ + Conversation  │
                    │     Memory      │
                    └─────────────────┘
                             │
                     Human escalation

The important distinction is that I wouldn't start with a swarm of autonomous agents. Start with one customer-facing agent plus well-defined tools and deterministic workflow steps. Add specialist agents only where they actually improve performance.

For example:

• lookup_order()
• check_refund_eligibility()
• issue_refund()
• change_shipping_address()
• search_knowledge_base()
• create_support_ticket()
• escalate_to_human()

Then maintain explicit state such as:

{
    "customer_id": "...",
    "order_id": "...",
    "issue": "damaged_item",
    "refund_status": "pending",
    "verification_status": "verified",
    "conversation_summary": "...",
    "next_action": "awaiting_customer_photo"
}

That's where LangGraph's stateful/durable execution model becomes particularly valuable.

One important design principle

For customer service, workflow control matters more than "agent intelligence."

You want the system to be able to say:

"I need to verify the customer's identity → retrieve order → determine eligibility → ask for missing information → wait → resume the same workflow → issue refund → confirm." rather than simply giving an LLM a giant collection of tools and hoping it figures everything out.

I'd also put guardrails around every consequential tool call—particularly refunds, account changes, cancellations, and anything involving personal data. The OpenAI Agents SDK, for example, supports tool-level guardrails specifically for validating calls before and after execution.

Bottom line:

• If you're building a serious production customer-service system with complex workflows, choose LangGraph.
• If you want to get a capable OpenAI-based agent running quickly, choose OpenAI Agents SDK.
• If I were starting your project from scratch, I'd probably use LangGraph + an LLM + your existing business APIs + a proper persistent database, rather than making the LLM itself responsible for managing all state.

If you tell me your stack (Python/TypeScript, OpenAI/Anthropic/etc.) and the kinds of customer-service tasks the agent needs to handle, I can recommend a concrete architecture and folder structure.

One important design principle

For customer service, workflow control matters more than "agent intelligence."

You want the system to be able to say:

"I need to verify the customer's identity → retrieve order → determine eligibility → ask for missing information → wait → resume the same workflow → issue refund → confirm." rather than simply giving an LLM a giant collection of tools and hoping it figures everything out.

I'd also put guardrails around every consequential tool call—particularly refunds, account changes, cancellations, and anything involving personal data. The OpenAI Agents SDK, for example, supports tool-level guardrails specifically for validating calls before and after execution.

Bottom line:

One important design principle

For customer service, workflow control matters more than "agent intelligence."

You want the system to be able to say:

For complex, multi-turn customer service conversations, the "best" framework depends on whether you need strict deterministic control (guardrails and compliance) or dynamic, multi-agent collaboration . Customer service requires high reliability, state management across long conversation histories, and secure tool-calling (like looking up order statuses or processing refunds).

The top framework options mapped to specific customer service architectures include:

- **Why it shines:** Customer service cannot afford "hallucinated" procedural steps (e.g., promising a refund without checking policy). LangGraph models agent interactions as cyclic graphs, giving you explicit control over state, memory persistence, and human-in-the-loop triggers.
- **Best used when:** You need rock-solid guardrails, deterministic routing between support stages (e.g., Greeting → Troubleshooting → Supervisor Handoff), and robust checkpointing. Check out LangGraph to see how state graphs operate.[](https://www.youtube.com/watch?v=3JTzZjaWPjg&t=422) [[1]](https://www.youtube.com/watch?v=3JTzZjaWPjg&t=422)

- **Why it shines:** It integrates natively with enterprise identity management, existing backend systems, and multi-language enterprise tech stacks (C#, Python). It treats plugins and LLMs as standard software components, making secure API calling straightforward.
- **Best used when:** Your customer service backend runs on enterprise Microsoft infrastructure or strict corporate IT environments. Explore Semantic Kernel for enterprise patterns.[](https://www.youtube.com/watch?v=RSvYae1L9YI&t=586) [[1]](https://www.youtube.com/watch?v=RSvYae1L9YI&t=586)

- **Why it shines:** Instead of one monolithic prompt trying to handle every customer issue, these frameworks let specialized agents talk to each other. A front-facing conversational agent can delegate a technical log-parsing task to a backend-data agent.
- **Best used when:** Your support inquiries require complex, cross-departmental coordination rather than a straightforward conversational script. Look into CrewAI for role-based multi-agent orchestration.

- **Why it shines:** If you are building a custom-tailored chat UI with real-time streaming, tool-calling loops, and lightweight state handling directly inside a modern web application stack, these developer-focused frameworks minimize overhead.

Summary Recommendation

If your primary pain point is preventing the agent from going off-script or making costly operational errors , go with LangGraph . If your primary need is heavy enterprise backend integration and governance , choose Semantic Kernel.

To help narrow down the ideal choice, tell me:

• What kind of backend systems does the agent need to talk to (e.g., Salesforce, Shopify, custom SQL databases)?
• Do you require a human-in-the-loop escalation workflow?
• What is your preferred programming language/tech stack (Python, TypeScript/Node.js, C#)?

For complex, multi-turn customer service conversations, your agent needs precise state management, reliable tool integration (like checking order status or processing refunds) , and strict guardrails to prevent hallucinations or going off-script.

The top production-grade frameworks for this use case approach the problem via different architectural styles:

• LangGraph (by LangChain) is best for strict, stateful, and cyclic workflows . It models conversations as a graph of nodes and edges, allowing you to pause, checkpoint, and inspect state at every single turn. If your customer service agent requires strict compliance, deterministic handoffs (e.g., routing to a human agent only under exact conditions), and robust memory management, LangGraph is top-tier.
• CrewAI is best for role-based multi-agent collaboration and rapid prototyping . It lets you set up specialized agents (e.g., a "Greeter Agent," a "Technical Support Agent," and a "Billing Specialist") that pass tasks back and forth. It’s intuitive and fast to set up, though managing hyper-strict deterministic paths can be slightly trickier than with a graph-based tool.
• Microsoft Agent Framework is best if you are embedded in the enterprise .NET/Azure ecosystem . Serving as a unified evolution combining elements of AutoGen and Semantic Kernel, it excels at secure enterprise integrations, multi-agent conversations, and heavy backend tool-calling.
• Pydantic AI is best for type-safe, structured, and predictable outputs . If your primary worry is that the LLM will return malformed data or misinterpret a tool schema during a complex conversation, Pydantic's focus on data validation and model agnosticism makes for exceptionally robust single- or multi-turn agent logic in Python.

To help narrow down the ideal choice, tell me:

• Will this agent need to integrate with specific enterprise systems (like Salesforce, Zendesk, or custom SQL databases)?
• Do you prefer a code-first Python approach or a visual/low-code builder?
• Is it strictly text-based (chat) or handling voice/telephony?

For a customer service agent that handles complex, multi-turn conversations, I would generally choose a framework that gives you:

• Persistent conversation state (the agent remembers context across turns)
• Deterministic workflow control (important for refunds, account changes, escalations, compliance)
• Tool calling (CRM, ticketing, billing, knowledge bases)
• Human handoff
• Observability and evaluation
• Guardrails around what the model can and cannot do

There is no single universal winner, but these are the strongest choices:

1. LangGraph — best default for complex customer service agents

For a serious support agent, this is often my top recommendation. It models the agent as a stateful graph: conversation states, tool calls, approvals, retries, and escalation paths are explicit rather than hidden inside a prompt loop.

Good fit for:

• Tier-1 support automation
• Multi-step troubleshooting
• Account workflows
• Human approval steps
• Long-running conversations

Example architecture:

Customer
   |
Intent + context extraction
   |
Conversation state manager
   |
+----------------+
| Agent decision |
+----------------+
   |
   +--> Knowledge search
   |
   +--> CRM lookup
   |
   +--> Billing system
   |
   +--> Human escalation

Strengths:

• Excellent control over complex flows
• Easier debugging than fully autonomous agents
• Good fit for production workloads

Tradeoff:

• More engineering effort than simple chatbot frameworks

Vercel

2. OpenAI Agents SDK — best if you want a simpler agent stack

This is a good choice if you want:

• Tool use
• Agent handoffs
• Guardrails
• Tracing
• A relatively lightweight abstraction

It works well for support agents where the workflow is mostly:

User question
→ Agent reasons
→ Calls tools
→ Responds
→ Escalates if needed

Good fit:

• SaaS support bots
• Internal help desks
• Teams already building around OpenAI models

Tradeoff:

• For very complicated branching business processes, you may still want a workflow layer around it.

AIUnpacking

3. Rasa — best when reliability and strict control matter

Rasa takes a more traditional conversational AI approach: separating dialogue management from generative responses. It can be attractive for regulated industries or environments where you need predictable behavior.

Good fit:

• Banking
• Healthcare
• Insurance
• High-compliance customer support

Strengths:

• Strong control over conversation paths
• Self-hosting options
• Mature dialogue concepts

Tradeoff:

• Less flexible for open-ended reasoning compared with LLM-native agent frameworks

---

4. Microsoft Agent Framework — best for Azure/.NET enterprises

If your organization is already deeply invested in Microsoft tooling, this is worth considering. It targets enterprise agent orchestration, including workflow patterns and integrations.

Good fit:

• Azure environments
• Enterprise IT support
• Microsoft ecosystem integrations

---

My recommendation by scenario

Rasa Workflow BuilderFor a production customer service agent, I would usually build:

• Agent orchestration: LangGraph or OpenAI Agents SDK
• Knowledge retrieval: vector database + RAG pipeline
• Memory: customer profile store + conversation state store
• Tools: CRM, order system, ticketing, billing APIs
• Safety: permissions, tool constraints, escalation rules
• Evaluation: conversation replay + human review metrics

The key design choice is not making the model "smarter"; it is making the agent reliable when conversations become messy: interruptions, missing information, angry customers, policy exceptions, and multi-step tasks.

For a customer service agent that must handle complex, multi-turn conversations, the best framework depends on how much control you need over conversation state, workflows, tools, and enterprise constraints. There is no single winner, but a few frameworks stand out.

My shortlist

For your specific goal: customer service + multi-turn complexity

I would usually start with:

1. LangGraph as the orchestration layer

• Persistent conversation state
• Explicit workflow control
• Tool calling (CRM, order systems, billing, ticketing)
• Human handoff points
• Easier debugging than a purely free-form agent loop
  

A typical architecture:

Customer
   |
Chat / Voice Channel
   |
Conversation Manager (LangGraph)
   |
   +-- Intent + context tracking
   +-- Knowledge retrieval (RAG)
   +-- Business tools
   |      +-- CRM lookup
   |      +-- Order status
   |      +-- Refund workflow
   |      +-- Ticket creation
   |
   +-- Human escalation

When I would choose Rasa instead

Choose Rasa if:

• The agent handles regulated workflows (banking, healthcare, government)
• You need predictable behavior over open-ended reasoning
• You need on-prem deployment or strict data boundaries
• Compliance teams require detailed conversation control
  

Features I would prioritize regardless of framework

For a real customer service agent, don't optimize only for "smart replies." Prioritize:

1. Durable memory

   • Remember customer identity, previous issues, preferences, and unresolved tasks.

2. Workflow control

   • A refund, cancellation, or account change should follow defined steps.

3. Tool safety

   • The model should not directly perform sensitive actions without validation.

4. Observability

   • Log why the agent made decisions and where conversations fail.

5. Human escalation

   • Transfer with full context, not just a transcript.

Practical recommendation

• Startup / product team: LangGraph + retrieval layer + your preferred LLM provider.
• Large enterprise on Azure: Microsoft Agent Framework.
• Highly regulated support: Rasa.
• Document-heavy support (internal knowledge): LangGraph + LlamaIndex-style retrieval.

For most teams building a modern customer service agent from scratch, LangGraph is probably the strongest default choice today because it gives you the control needed for long-running, multi-step conversations without forcing every interaction into a rigid chatbot flow.

A good next design decision is not the framework itself but the agent architecture: single agent with tools vs. planner/router + specialist agents. For customer service, the former is often the better starting point.

For complex, multi-turn customer service conversations—where an agent needs to remember context across dozens of turns, execute multi-step tool calls (like looking up an order, processing a refund, and updating a CRM), and gracefully handle ambiguity—there is no single "magic bullet" framework . Instead, choices split based on your architectural needs and tech stack.

The leading frameworks for building stateful, production-ready conversational agents break down as follows:

1. LangGraph — The Production Standard for Stateful Workflows
   • Why it fits: Built by the LangChain team, it models agent interactions as stateful graphs (nodes and edges) with native support for cyclic loops and persistence. For customer service, this means you can cleanly checkpoint a conversation state at any turn, handle branching logic (e.g., if a customer is angry vs. asking a technical question), and insert human-in-the-loop approval gates (like manager sign-off for a high-dollar refund).
   • Best used for: Complex, highly deterministic, and production-grade conversational flows where failure is expensive.
2. CrewAI — Best for Rapid Prototyping & Role-Based Swarms
   • Why it fits: Uses a human-like metaphor where you assign specific roles, goals, and backstories to agents (e.g., a "Tier 1 Greeter Agent" handing off to a "Technical Specialist Agent"). It has a very low barrier to entry and lets you get a multi-agent prototype running with minimal code.
   • Best used for: Teams looking for the fastest path from an idea to a working multi-agent collaboration demo.
3. Microsoft AutoGen — Best for Conversational Multi-Agent Loops
   • Why it fits: Designed from the ground up for conversational multi-agent interaction, allowing different specialized agents to "talk" to each other to solve a problem or debate the correct policy response before answering the user.
   • Best used for: Complex back-and-forth orchestration and environments deeply integrated into the Azure ecosystem.
4. OpenAI Agents SDK — Best for Lightweight OpenAI-Native Handoffs
   • Why it fits: If your stack relies tightly on OpenAI models, this lightweight option handles tool use, guardrails, and smooth conversational handoffs between different agent prompts with minimal overhead.
   • Best used for: Fast development and teams that don't need a heavy infrastructure framework.
5. Google Agent Development Kit (ADK) — Best for Multimodal & Google Cloud Stacks
   • Why it fits: Tailored for Gemini models on Vertex AI, it natively handles text, voice, and visual inputs alongside built-in session state management and agent-to-agent protocols.
   • Best used for: Voice-based customer support flows or teams embedded in Google Cloud.

To help narrow down the ideal choice for your project, let me know:

• Is your primary channel text (chat/SMS) or voice (telephony/WebRTC)?
• What programming language is your backend built in (Python vs. TypeScript/.NET)?
• Will the agent need to autonomously execute database/API mutations (like issuing refunds), or primarily retrieve information (RAG)?

Building a customer service agent that handles complex, multi-turn conversations requires a framework with strong state management, flexible tool integration (function calling), and robust human-in-the-loop or fallback capabilities.

Several frameworks stand out for production-grade conversational agents in 2026, categorized below by their core strengths:

1. Graph and State-Based Orchestration

• LangGraph : Built on top of LangChain, this framework explicitly models agent workflows as cyclic graphs (nodes and edges). It is arguably the gold standard for complex, multi-turn state management because it allows you to define exact conversational flows, persistent checkpointing (saving conversation state to a database), and precise control over when an agent loops or terminates.
• Semantic Kernel (Microsoft) : An enterprise-grade SDK by Microsoft that integrates tightly with traditional programming languages (C# and Python). It excels in enterprise environments where you need to orchestrate plugins, native code, and LLM prompts smoothly across multi-turn enterprise systems.

2. Autonomous and Multi-Agent Frameworks

• CrewAI : Designed around the concept of role-playing autonomous agents. While often used for task automation, it can be structured for customer service scenarios where specialized agents (e.g., a billing specialist, a technical support agent, and a supervisor router) collaborate to resolve multifaceted issues.
• AutoGen (Microsoft) : A powerful multi-agent conversation framework that allows agents to converse with each other to solve complex tasks. It's highly customizable for intricate routing, though it requires more upfront engineering to lock down predictable behavior for public-facing customer service.

3. Developer-First & Lightweight Control

• LlamaIndex (Workflows) : Best known for data ingestion and RAG (Retrieval-Augmented Generation), LlamaIndex features a robust event-driven workflow engine. If your customer service agent needs to heavily query internal knowledge bases, user manuals, and ticketing systems across turns, this event-driven approach keeps execution clean and traceable.
• Direct Provider APIs (OpenAI Agents SDK / Anthropic) : Often, the most reliable multi-turn system is built directly on top of native API primitives (like Assistants/Agent APIs or structured tool loops) rather than heavy third-party frameworks. This minimizes abstraction fatigue and gives you raw control over token management and prompt caching.

Key Considerations for Customer Service

• State Persistence : Ensure the framework supports external state saving (like Redis or Postgres) so users don't lose context if a session drops or a server restarts.
• Deterministic Guardrails : Pure LLM autonomy can lead to hallucinations or going off-script with customers. Look for frameworks that let you combine deterministic logic (e.g., hardcoded routing rules for refunds) with probabilistic LLM reasoning.

To help narrow down the best choice, tell me:

• What is your primary tech stack (Python, Node.js, C#, etc.)?
• Will the agent need to integrate with specific CRM/ticketing software (like Zendesk or Salesforce)?
• Do you prefer a code-first approach or a visual/managed platform?

For a complex, multi-turn customer-service agent, I’d choose based on how much control you want over state and orchestration:

My recommendation: OpenAI Agents SDK

If you’re primarily using OpenAI models, the OpenAI Agents SDK is probably the best starting point. It gives you a relatively small set of primitives—agents, tools, handoffs, guardrails, sessions, and tracing—without forcing you into a large orchestration abstraction.

It maps particularly well to customer support:

                    ┌─ Billing Agent
                    │
Customer → Triage ──┼─ Returns Agent
                    │
                    ├─ Technical Support Agent
                    │
                    └─ Human Escalation

You can use handoffs when a specialist should take over the conversation, or agents-as-tools when a central agent should remain responsible for the final response.

The SDK also has persistent sessions, which is important for your requirement: the agent can carry conversation history across separate runs rather than you manually reconstructing the context every turn.

When I'd choose something else

A recent 2026 comparison similarly positions LangGraph for stateful multi-agent orchestration and the OpenAI Agents SDK for tightly scoped assistants and lightweight multi-agent delegation.

The architecture I'd use

Don't make the LLM responsible for everything. For customer service, I'd build:

1. Conversation/session layer
Persistent customer + conversation state.

2. Triage agent
Determines intent and routes to the appropriate capability.

3. Specialist agents/tools
For example:

• Order lookup
• Returns/refunds
• Billing
• Account management
• Product troubleshooting
• Shipping
• Knowledge-base search

4. Deterministic business logic
Refund eligibility, account permissions, pricing, etc. should be enforced by your backend—not merely by prompting the model.

5. Guardrails
Validate tool calls and outputs, particularly before actions that change customer data or issue refunds. The Agents SDK supports input/output and per-tool guardrails.

6. Human escalation
Have an explicit path for cases the agent can't safely resolve.

7. Observability + evaluation
Track tool selection, resolution rate, escalation rate, hallucinations, conversation abandonment, and cost—not just whether the final answer "sounds good."

One important design choice

I would not start with a swarm of autonomous agents.

Start with:

one primary agent + well-defined tools + persistent session state

Then introduce specialist agents when there's a genuine reason to separate prompts, permissions, models, or responsibilities.

For example, "What's the status of my order?" should probably be a tool call, not a separate agent. But a complicated billing dispute involving several policies and multiple backend operations may justify a Billing Specialist.

If you expect very long-running, branching workflows—e.g. conversations that pause for hours/days, wait for humans, resume, execute many conditional steps, and need explicit durable state—I'd lean toward LangGraph instead. That's where its explicit workflow/state model becomes particularly valuable.

Bottom line: for your stated goal, I'd start with OpenAI Agents SDK + persistent sessions + backend tools + a small number of specialist handoffs. It gives you a clean path from prototype to a genuinely multi-turn support system without prematurely building a complicated orchestration engine.

If you tell me your stack (Python/TypeScript, OpenAI vs multiple model providers, and what customer-service tasks the agent needs to perform), I can recommend a concrete architecture and folder structure.

The best framework for building a customer service agent capable of managing complex, multi-turn conversations is LangGraph (built by the LangChain team).

Unlike traditional Linear or Chain-of-Thought AI architectures, complex customer support requires looping logic, state tracking, and strict deterministic flows (like verifying an identity before initiating a refund). LangGraph allows you to model your agent as a State Graph , mapping out exact conversation node paths while giving the LLM autonomy where needed.

Depending on your engineering resources and infrastructure preferences, the landscape can be broken down into three categories:

1. Code-First Developer Frameworks (Maximum Control)

If you are writing the backend system integration from scratch and need absolute control over agent state memory, routing, and tool calling, choose one of these:

• LangGraph:
  • Why it wins : It is natively built for cyclic graphs (loops), which are necessary when an agent needs to ask clarifying questions, retry a failing API call, or circle back to a previous validation step.
  • It maintains a persistent conversation state database, letting you build custom "human-in-the-loop" approval features.
• Microsoft AutoGen:
  • Why it wins : Excellent if your support workflow requires multi-agent orchestration.
  • You can assign separate "specialist" agents (e.g., a Billing Agent, a Technical Triage Agent, and a Refund Approver) that talk to each other to solve a single customer's problem.
• PydanticAI:
  • Why it wins : A newer, developer-centric option structured heavily around type safety and robust validation. It is ideal if your agent relies on structured data data inputs/outputs.

2. Visual-Orchestration Frameworks (Low-Code / Hybrid)

If you want the flexibility of a developer framework but prefer a drag-and-drop workflow interface to map out conversation states, use:

• Langflow : A visual IDE for building LangChain and LangGraph systems. It bridges the gap perfectly for engineering teams that want to visualize the information flow from customer intent to database retrieval.
• Voiceflow : High-performing state-management capabilities specifically designed for conversation design. It allows product managers and developers to collaborate on multi-turn dialogue logic simultaneously.

3. Managed Enterprise Platforms (No-Code Out-of-the-Box)

If your goal is to launch a highly capable enterprise agent quickly without building the underlying infrastructure, look toward dedicated Customer Experience (CX) AI platforms:

• Sierra : Tailored for enterprise-grade, outcome-oriented customer resolutions rather than simple FAQ deflection. It excels at natural-language logic and safety.
• Decagon : Uses natural language logic instead of rigid decision trees to seamlessly manage varied customer phrasing and multi-step transactions.
• ASAPP : Features an embedded "Human-in-the-Loop" model that connects complex multi-turn conversations directly to human agents when the AI hits its boundary.

Key Requirements Checklist for Complex Multi-Turn Support

Whichever framework you pick must handle these specific hurdles:

To help point you toward the most specific framework tool, tell me a bit more about your stack:

• What backend systems or CRMs (e.g., Salesforce, Zendesk, Stripe, custom API) does the agent need to communicate with?
• Does your team prefer writing pure Python/TypeScript code , or do you need a visual, drag-and-drop interface?
• Will the agent be deployed on web chat, email, voice , or across multiple channels?

For a customer service agent that must handle complex, multi-turn conversations, the best framework is usually one that gives you explicit conversation state, tool orchestration, memory, human handoff, and observability—not just a chatbot wrapper.

There is no single winner, but these are the strongest choices:

My recommendation for a serious customer service agent

For most modern support systems, I would start with:

LLM + LangGraph + retrieval layer + business tools + human escalation

A typical architecture:

Customer
   ↓
Conversation API (web/chat/voice)
   ↓
Agent Orchestrator (LangGraph)
   ↓
 ┌───────────────┬───────────────┐
 │               │               │
Intent Agent   Knowledge RAG   Action Tools
 │               │               │
Billing API   Docs/FAQ       CRM/Ticketing
 │               │               │
 └───────────────┴───────────────┘
          ↓
Human escalation when needed

The important pieces are:

• Conversation state
  • Track customer identity, issue history, previous promises, authentication status.
• Memory
  • Short-term: current conversation.
  • Long-term: customer preferences, previous tickets, account history.
• Tool calling
  • Refunds, order lookup, scheduling, account changes, ticket creation.
• Guardrails
  • Prevent unauthorized actions.
  • Require confirmation for sensitive operations.
• Human-in-the-loop
  • Escalate when confidence is low or the customer is frustrated.
• Evaluation
  • Measure resolution rate, hallucinations, escalation quality, and customer satisfaction.

When I would choose something else

• Choose Rasa if your support workflows are regulated and need predictable behavior more than maximum flexibility.
• Choose OpenAI Agents SDK if you want the fastest path to a clean agent system and you are comfortable building around OpenAI tooling.
• Choose Microsoft Agent Framework if your organization is deeply invested in Azure/Microsoft.
• Choose LlamaIndex if the hardest problem is knowledge retrieval rather than conversation control.

For a Tier-1 customer support agent handling thousands of conversations, I would prioritize production reliability over autonomous “smartness.” A well-designed state machine around an LLM generally beats a free-form agent loop.

If you share your expected scale (e.g., 1k vs 1M conversations/month), channels (chat, phone, email), and backend systems (Salesforce, Zendesk, custom CRM), the recommendation can be narrowed significantly.