Coding Reliable LLM-based Integrated Task and Knowledge Agents with GenieWorksheets

The paper introduces Genie, a framework for developing reliable, task-oriented conversational agents powered by large language models (LLMs). Using Genie Worksheets, a high-level specification language, developers can precisely define conversation flows, task logic, and access to both structured and unstructured knowledge sources. This structured approach enables Genie agents to manage complex, context-sensitive dialogues with high accuracy. Unlike conventional LLMs, Genie uses a symbolic agent policy, reducing common issues like hallucinations and inconsistency. Genie significantly outperforms models like GPT-4 in real-world scenarios, such as restaurant reservations and course enrollment, achieving superior execution accuracy and task completion rates.

This article introduces a new framework called Genie, designed to create task-oriented conversational agents capable of handling complex user interactions and knowledge queries. Genie is implemented through a programmable framework called the Genie Worksheet, which allows developers to define dialogue tasks, knowledge base schemas, API interfaces, and examples in a declarative manner for the large language model (LLM) parser to understand. Genie’s core advantage lies in its ability to provide reliable and controlled agent strategies, achieved through its highly expressive specifications.

This paper proposed a agent framework called Genie worksheets, which allows developers to easily build customized LLM agent workflows for specific downstream applications. In particular, the developers only needs to specify the available knowledge bases, the database schema and a few in-context examples or expected workflows in the worksheet, and then the LLM agent will be able to assist users by interacting with the knowledge bases and ask follow-up questions as needed. The authors evaluated the proposed framework on a static dialog state tracking dataset and conducted user-studies to measure the user’s preference between Genie and GPT-4 function calling.

This paper introduces GENIE, a programmable framework designed to make it easier for developers to rapidly build conversational agents by specifying the desired behavior of the agent via declarative language.

The main technical contribution of this paper is Genie Worksheet, a declarative specification language that serves multiple objectives, including (1) allowing developers to define complex agent behaviors as declarative policy, (2) integrating both structured and unstructured knowledge into the conversation history to support accurate, knowledge-informed conversations, (3) supporting contextual and complex managements of the dialogue state tracking, even through the complex mixed-initiative scenarios.

The authors present promising empirical results where GENIE (based on GPT-4-turbo) outperforms previous state-of-the-art models (based on T5) as well as GPT-4-turbo with function calling, validated by both existing benchmarks and real-user studies.

In a nutshell, this paper demonstrates that with a symbolically guided design of a worksheet that specifies the conversation history and policy carefully, it is possible to considerably increase the performance and the reliability of LLMs serving as knowledge-intensive conversational agents. This finding is perhaps analogous to the recent trend of test-time inference methods that can increase the performance of the base LLMs. The proposed approach relies on the capabilities of underlying LLMs to accurately work with the Genie Worksheet via In-Context-Learning instructions and examples, thus is subject to the errors that may be caused by the underlying LLMs.

Overall this paper reads a bit like a white paper of a product release due to the emphasis on the design objectives for the developers and relatively less focus on the technical implementations, thorough ablation studies, or comprehensive comparisons against other competitive baselines.

The paper introduces Genie, a framework designed to make LLM-based task-oriented agents more reliable and user-friendly. Traditional conversational agents struggle with handling complex logic, maintaining context, and accurately responding to dynamic user inputs. Genie tackles these issues with the Genie Worksheet—a high-level, declarative specification tool that lets developers define agent behavior, control conversation flow, and integrate knowledge sources directly. The result is an agent that can handle mixed user queries, remember important details across long interactions, and reliably follow developer-defined instructions. In tests, Genie outperformed state-of-the-art models and GPT-4-based systems on several metrics, showing a big boost in accuracy and task completion.

Experiment with new baselines (Reviewer HkEW, xQvx)

To get more updated baselines, we run new experiments with Llama-3.1 instruct 70B and GPT-4 turbo on STARv2.

For zero-shot settings, we prompt the LLM with natural language policy (an example is shown below), current belief state (dialogue state) as provided in STARv2, the agent acts with description, and the user utterance. We ask the LLM to select the next agent act according to the given input.

The first four rows and the last row are from Table 1 in our paper. The table shows the performance (measured by System Act F1) of different models on STARv2. (+P) represents the use of programmable policies.

• We find that the previous SOTA, AnyTOD-PROG+SGD XXL, is still a strong baseline: even though the previous SOTA was based on T5, it still outperformed zero-shot baselines with stronger models: llama-3.1 70B and GPT-4 turbo.

Genie with different base models (Reviewer HkEW, xQvx)

To evaluate how Genie performs with different base models, we run three new experiments with LLama 3.1 Instruct 70B and GPT 4 Turbo.

We observe the following:

• Genie improves the performance of base LLMs: Genie (llama-3.1) and Genie (GPT-4 turbo) significantly improve the performance of the base models across all domains by up to 33.16 points and 40.70 points, respectively.
• Genie can elevate the performance of weaker LLMs to that of much stronger LLMs: The experiments also highlight that in some domains, llama 3.1 70b can achieve similar performance to GPT-4 turbo, for example, in the banking domain.

Example of Natural Language Policy used for zero-shot experiments for banking domain:

1. **Initial Request for Information**:
   - The process begins with a request for the user's **Full Name**, **Account Number**, and **PIN**.
   - If the user is unable to provide these details, they are prompted for **additional information**:
     - **Full Name**
     - **Date of Birth**
     - **Security Answer 1** (e.g., Mother's maiden name)
     - **Security Answer 2** (e.g., Name of childhood pet)

2. **User Information Submission**:
   - If the user provides the requested information, the process continues.
   - If the user fails to provide the required information, they are again prompted, and the process either proceeds or halts based on the completeness of their response.

3. **Request for Fraud Details**:
   - Upon successful submission of initial authentication details, the system requests specific details for the fraud report.

4. **Querying the Bank Fraud Report**:
   - The system queries the **Bank Fraud Report** database to validate the user's information and report the fraud.

5. **Outcome**:
   - **Success**: If the user's details are authenticated successfully, they are informed that their fraud report has been recorded.
   - **Authentication Failure**: If the system cannot authenticate the user's information, they are informed that their identity could not be verified, and the process terminates.

Thank you all for your insightful feedback on the paper’s experiments and presentation.

What is the scientific contribution and what is the intuition behind the Genie framework (Reviewer: 9gVR, xQvx, cLiY)

This research asks the question: can we automatically derive an effective task & knowledge-oriented agent from a minimum specification, handling users’ expected utterances including questions relevant to the task.

The Worksheet specifies all the information needed, the actions to take, and the knowledge to supply. We consider this to be minimal, because no system can intuit the details without the developer specifying them. In other words, while it may not be easy to come up with the specification for a complex task, it is unavoidable.

As a minimal specification, it is a great departure from previous solutions: (1) dialogue trees where the developer has to code up the agent actions for possible conversational states in each application, or (2) learning from wizard-of-oz conversations, whose annotations are shown to be erroneous despite multiple rounds of re-annotation. [1, 2, 3, 4]

The key intuitions and novel scientific contributions that enable Genie to perform better than any other systems are:

1. Our first insight is that existing formal dialogue representations in academic papers cannot capture the interactions necessary to complete complex tasks. Our first contribution is a sophisticated specification/representation that is expressive enough to handle complex tasks.

Previous task-oriented dialogue states (such as MultiWOZ) contain only simple slot-value pairs, and previous knowledge agents only support formal database queries. This cannot address the needs in real life, and thus are not used in practice. We get inspired by how the GUI-based forms are used in handling all sorts of tasks–we need to at least handle that level of complexity. We also add to it the flexibility of users asking for additional knowledge and providing information in any order they want. This led us to design the Genie worksheet (nested worksheets, task and database schemas, actions attached to cell values, conditional fields, cell values that can be results of queries, composition of queries and actions, etc).

2. Our second insight is that human agents can perform many tasks, mostly by reading, interpreting, and filling out the equivalent of forms on the web (Sec 2), without being “trained” with conversations for each specific application. This leads us to ask if we can emulate what human workers do; we wish to factor the agent into a generic strategy that interprets the specification of the application. Our second contribution is to show that this is possible and our framework has been demonstrated to successfully translate a specification into a robust agent. Our experiments show that an algorithmic generic strategy suffices, and we don’t need a neural policy. The strategy is to service all users’ requests first, then examine the dialogue state to determine the next step according to the specification (e.g. performing an action or asking a question). This design seamlessly supports mixed initiatives and integrates the functions of knowledge-oriented and task-oriented agents. We do not know of any other prior work that provides this combination successfully.

Previous run-time policies are either neural or finite state machines. They cannot handle the complexity of a real dialogue with mixed user and agent initiatives. The former will lose track of the state in long conversations, and the latter will have an exponential number of states.

3. The third insight from our experiment is that if we provide the specs to LLMs and natural language instructions of the agent policy, LLMs would fail: (1) it would forget about key information provided from previous turns in the dialogue, leading to the LLM-based agent repeatedly asking questions and hallucinating information about the user. (2) LLMs cannot follow all the given instructions. This justifies the adoption of the classical agent pipeline with an LLM-based semantic parser that translates the natural language into a formal representation, an algorithmic agent policy, and an LLM-based response generator.

4. Given the more sophisticated dialogue representation, it is unclear if an LLM-based parser can be accurate enough. This paper provides empirical evidence that this is possible by using a formal dialogue state as context, rather than the actual conversation sequece. To handle the full complexity of the Worksheet dialogue state, design choices that contribute to the success include: a two-tier structure that calls a separate agentic LLM-parser for queries (Section 3.2), we are the first to adopt Python to handle our complex dialogue states.

Scientifically, there is prior work that generates an agent from a declarative schema, Genie is the first that generates a robust task/knowledge agent from a declarative specification.

We sincerely thank the reviewers for their thoughtful and positive feedback on our work. Multiple reviewers appreciated our novel framework (Reviewers xQvx, phJk, 9gVR, HkEW), highlighting the innovative worksheet structure that allows for precise control and knowledge access (xQvx) and the ability to define complex agent behavior as declarative policies (HkEW). The enhanced reliability and controllability of LLM-based agents were noted (xQvx, phJk, HkEW, 9gVR), emphasizing improved task consistency and performance, reduced hallucinations (xQvx), and reliable adherence to developer-defined instructions (9gVR). All the reviewers acknowledged our framework's superior performance compared to models like GPT-4 (phJk, cLiY, HkEW, xQvx, 9gVR), and its capacity to handle complex user interactions, integrate structured and unstructured knowledge, and manage dialogue states effectively (phJk, HkEW, 9gVR). Additionally, the expressiveness and customization capabilities of our approach (phJk, cLiY, HkEW), along with its accessibility for non-technical developers (cLiY, were commended. We are pleased that the promising empirical results and real-world applications were recognized (xQvx, phJk, HkEW), and that our work can aid future research efforts (phJk).

We have provided clarification and new experimental results. We will add them to the updated version of our manuscript. If you have any additional questions, we will be happy to answer them!

The paper introduces GenieWorksheets, a framework for developing task-oriented conversational agents that integrate task management and knowledge access. By providing a declarative language for defining dialogue tasks, API interactions, and knowledge integration, Genie aims to enhance the reliability and scalability of LLM-based agents. Experimental results demonstrate performance improvements over GPT-4 Turbo on various benchmarks, including STARv2, with better execution accuracy and goal completion rates.

Despite these contributions, the paper has critical weaknesses. The novelty of GenieWorksheets is limited, as it primarily integrates existing ideas in a structured way without substantial innovation. Comparisons with established frameworks like LangChain and AutoGen are inadequate, and the evaluation lacks diverse tasks and datasets to validate generalizability. Methodological clarity is also an issue, with insufficient details provided for reproducibility. The presentation is difficult to follow, with high-level abstractions and limited concrete examples, reducing the paper’s accessibility.

Strengths include the focus on reliability and the attempt to bridge task-oriented and knowledge-based functionalities in conversational agents. However, the lack of strong experimental validation, insufficient novelty, and poor presentation outweigh the contributions.

Reject