Enterprise AI Analysis Report

Introduction: Bridging LLM Planning to Real-World Complexity

Large Language Models (LLMs) excel at short-horizon, sequential tasks, but real-world decision-making demands more. Consider a cooking assistant: it must handle time delays (e.g., boiling spaghetti), diverse long-horizon tasks (multiple objectives, dependencies), and multi-agent coordination. These require asynchronous planning. Current benchmarks fall short, lacking interactive environments, time delays, and multi-agent support. ROBOTOUILLE addresses this gap with a simulator for diverse cooking recipes, featuring customizable JSON backends for states, actions, and goals. It offers turn-based and real-time multi-agent execution, along with three datasets (synchronous, asynchronous, multi-agent) and baselines for LLM evaluation and failure analysis.

ROBOTOUILLE Formalization: An MDP with Time-Delayed Effects

ROBOTOUILLE tasks are formalized as a Markov Decision Process (MDP), `M = `. Each state `s` comprises observable elements (`ŝt`, e.g., "lettuce1 is cut") and a set of timer variables (`Ht`) for managing time delays. Actions `a` (e.g., "Move robot1 from table1 to table2") have preconditions and can introduce new timers. The transition function `T` updates the state, removing expired timers and adding new ones for actions with delays. The JSON backend is highly customizable, allowing for new states, actions, and goals. Special effects handle complex interactions like delayed predicate additions (e.g., `iscooked` after a `cook` action delay). Language goals are flexible, accommodating combinatorial goal states. Procedural generation shuffles objects and adds new ones to create diverse scenarios. Multi-agent environments are supported, enabling turn-based or real-time control.

Dataset Details: Stress Testing LLMs Across Planning Dimensions

ROBOTOUILLE provides three core datasets—synchronous, asynchronous, and multi-agent—each with 10 unique tasks and 10 procedurally generated instances to comprehensively test LLM agents.

The Synchronous Dataset involves assembling sandwiches and burgers, with ingredients potentially needing to be cut. All cookable items are pre-cooked, focusing on sequential planning and ordering constraints. Tasks range from simple assembly to complex recipes with strict ingredient placement.

The Asynchronous Dataset extends this by initializing cookable ingredients as uncooked, requiring agents to manage time delays for cooking, frying, and boiling. This dataset includes sandwiches, burgers, fried recipes (e.g., French fries, fried onions), and soup, demanding efficient parallel planning to optimize task completion time.

The Multi-agent Dataset (detailed in Appendix A.3) challenges LLM agents in collaborative environments with 2-4 agents. Tasks involve making multiple recipes (burgers, sandwiches, soups) where agents share resources and may interfere, necessitating coordinated action and agreement on task order and ingredient usage. This dataset can be run in turn-based or real-time modes.

Experiments & Results: LLMs Struggle with Asynchronous Planning

We evaluated LLMs using I/O, I/O CoT, and ReAct baselines. The best performance was achieved by ReAct (gpt4-0), with 47% success on synchronous tasks but a significantly lower 11% on asynchronous tasks.

• Closed-loop agents are superior: ReAct consistently outperformed open-loop approaches (I/O, I/O CoT).
• Poor feedback incorporation: A major cause of asynchronous failure was the inability of ReAct to effectively recover from mistakes, leading to little progress toward the goal.
• Related failure modes: Both synchronous and asynchronous failures were dominated by rule violations and goal misinterpretation, indicating a common underlying challenge in adhering to environment constraints and understanding complex objectives.
• Task prioritization is critical: Properly prioritizing subtasks in asynchronous settings significantly boosts performance.

Analysis of optimality rates showed that while 55.3% of synchronous successes were optimal, only 9.1% of asynchronous successes were optimal, with 63.6% falling into the suboptimal (1, 1.25] bucket. This highlights the inefficiency in managing time delays.

Failure Mode Analysis: Rule Violations and Goal Misinterpretation

Our analysis categorized LLM failures based on uncertainties in the MDP (State, Action, Transition Function, Goal).

• Dominant Failures: In both synchronous and asynchronous settings, failures stemmed primarily from rule violations and goal misinterpretations.
• Synchronous Failures: Goal uncertainty (64.1%) was dominant, often due to incorrect initial goal understanding or misinterpretation during execution. Transition function uncertainty (32.1%), particularly violating the "one item at a station" rule, also contributed significantly.
• Asynchronous Failures: Transition function uncertainty (56.8%) was more dominant than goal uncertainty (34.1%). The "one item at a station" rule violation was even more prevalent (53.4%) due to a greater variety of stations (stoves, fryers, sinks), increasing recovery complexity.
• Asynchronous Recovery: LLMs exhibited worse recovery in asynchronous tasks, with higher rates of repeated transitions after failures, pointing to ineffective error recovery mechanisms.
• Follow-up Findings: Proper asynchronous prioritization boosts success (16% vs 6%). While stronger priors on transition rules reduced rule violations, overall performance did not significantly improve, as state interpretation failures (e.g., misinterpreting cooked status) increased.

Discussion: Pathways to Robust Asynchronous AI Agents

ROBOTOUILLE's findings highlight crucial avenues for improving LLM agents in complex, asynchronous environments:

• Feedback Incorporation: Current LLMs struggle with long contexts. Future work should focus on methods like summarizing interactions, using Retrieval-Augmented Generation (RAG) to reduce uncertainty, and fostering reasoning about future states to avoid myopic behaviors. Finetuning LLMs with reinforcement learning (e.g., TD learning) could also enhance performance.
• Self-Verification: LLMs are currently unreliable at self-auditing their plans. Integrating code-use with language (e.g., reasoning in language, verifying with code/APIs) could provide stronger, debuggable guarantees for plan correctness.
• Real-World Application: Deploying LLM agents in the real world requires addressing the cost and inference time challenges, especially for long-horizon tasks. Future directions for ROBOTOUILLE include developing an online platform for human-human and human-agent collaboration.

Related Work: ROBOTOUILLE's Unique Contribution

ROBOTOUILLE addresses critical gaps in existing LLM benchmarks:

• Asynchronous Planning: Unlike benchmarks focused on temporal logic (e.g., TRAM) or graph-based techniques (e.g., Plan Like a Graph), ROBOTOUILLE specifically provides an interactive environment with diverse cooking, frying, and boiling tasks that introduce real-time delays. Existing asynchronous benchmarks like AsyncHow lack interactivity, and Overcooked-AI has limited tasks without LLM agent integration.
• Diverse Long-Horizon Task Planning: While benchmarks like ALFWorld, WebShop, PlanBench, and VirtualHome offer long-horizon tasks (up to 96 steps), they often lack time delays or procedural generation for task diversity. ROBOTOUILLE combines long-horizon tasks with procedural generation and time-delayed actions.
• Multi-agent Planning: Many multi-agent benchmarks exist (e.g., AgentBench, MAgIC) but typically don't include time delays. Overcooked-AI has time delays but isn't an LLM-centric benchmark. ROBOTOUILLE integrates time delays into its multi-agent dataset (2-4 agents, turn-based or real-time), adding complexity through resource sharing and potential agent interference.