[Paper Review] Converse: A Tree-Based Modular Task-Oriented Dialogue System

Tian Xie, Xinyi Yang+14 more|arXiv (Cornell University)|Mar 23, 2022

AI in Service Interactions4 citations

TL;DR

Converse is a low-code, tree-based modular task-oriented dialogue system that uses an and-or tree structure (Task Tree) to model tasks and their dependencies, enabling flexible dialogue management, seamless task switching, and reusable dialogue policies. It simplifies bot development by eliminating the need to script individual dialogue turns, while supporting few-shot intent detection and extensible dialogue actions through a shared Policy Decision Tree.

ABSTRACT

Creating a system that can have meaningful conversations with humans to help accomplish tasks is one of the ultimate goals of Artificial Intelligence (AI). It has defined the meaning of AI since the beginning. A lot has been accomplished in this area recently, with voice assistant products entering our daily lives and chat bot systems becoming commonplace in customer service. At first glance there seems to be no shortage of options for dialogue systems. However, the frequently deployed dialogue systems today seem to all struggle with a critical weakness - they are hard to build and harder to maintain. At the core of the struggle is the need to script every single turn of interactions between the bot and the human user. This makes the dialogue systems more difficult to maintain as the tasks become more complex and more tasks are added to the system. In this paper, we propose Converse, a flexible tree-based modular task-oriented dialogue system. Converse uses an and-or tree structure to represent tasks and offers powerful multi-task dialogue management. Converse supports task dependency and task switching, which are unique features compared to other open-source dialogue frameworks. At the same time, Converse aims to make the bot building process easy and simple, for both professional and non-professional software developers. The code is available at https://github.com/salesforce/Converse.

Motivation & Objective

• To address the high maintenance cost and inflexibility of existing task-oriented dialogue systems that require scripting every dialogue turn.
• To enable easy adaptation to new tasks without retraining NLU models or rewriting dialogue flows.
• To support complex conversation patterns such as task switching and sub-task dependencies in a unified, composable framework.
• To reduce the barrier for bot development by enabling low-code configuration through structured Task Trees and reusable dialogue policies.
• To provide a modular, extensible architecture that supports both non-professional and professional developers in building and maintaining task-oriented bots.

Proposed method

• Representing tasks as and-or tree structures (Task Trees) that encode entities, sub-tasks, and their relationships for dynamic state management.
• Using a depth-first search traversal of a Policy Decision Tree to determine the next dialogue action based on current dialogue states and conditions.
• Implementing a few-shot natural language inference-based intent detection model that requires no fine-tuning or annotated data for new intents.
• Decoupling dialogue policy logic from task logic by sharing a single Policy Decision Tree across all tasks, enabling consistent and scalable dialogue control.
• Allowing bot builders to extend functionality by adding custom dialogue action code and updating the Policy Decision Tree configuration without modifying core logic.
• Supporting task switching and dependency resolution by maintaining persistent dialogue state across tasks and reusing authenticated states when needed.

Experimental results

Research questions

• RQ1 How can task-oriented dialogue systems be architected to support dynamic task switching without requiring pre-defined, rigid dialogue flows?
• RQ2 Can a tree-based task representation model complex task variations and dependencies more efficiently than traditional slot-based or flowchart-based approaches?
• RQ3 To what extent can few-shot intent detection reduce the need for annotated data and retraining when adding new tasks to a dialogue system?
• RQ4 How can a shared dialogue policy across multiple tasks improve maintainability and reduce development overhead?
• RQ5 What architectural patterns enable low-code bot development while preserving flexibility for complex, multi-intent interactions?

Key findings

• Converse enables bot builders to define new tasks through configuration files and Task Trees without writing dialogue flow logic, significantly reducing development time and complexity.
• The system natively supports task switching and sub-task dependency resolution, such as reusing authenticated user states across tasks, without requiring custom scripting.
• The few-shot intent detection model allows new intents to be added without annotated training data or model fine-tuning, lowering the barrier for new domain integration.
• The shared Policy Decision Tree enables consistent dialogue management across all tasks, reducing code duplication and improving maintainability.
• The tree-based architecture allows for dynamic traversal and state management, making it easier to update, debug, and extend tasks compared to traditional flow-based systems.
• The system is production-ready and has been deployed in real-world applications, demonstrating scalability and extensibility in complex, multi-task environments.