Abstract
This paper introduces STAPLE (Simulated Team-Agent Prolog-Language Environment), an architecture designed to enable artificial agents to engage in collaborative dialogue as a natural consequence of their internal reasoning. By embedding Joint Intention (JI) theory within a Belief-Desire-Intention (BDI) framework, STAPLE generates necessary communicative acts—such as status reports and requests for assistance—without the need for hard-coded interaction protocols. The system utilizes a hybrid Java-Prolog implementation to achieve real-time performance in simulated collaborative environments.
Introduction
In multi-agent systems, a persistent challenge is bridging the gap between task execution and communication. Traditional frameworks often treat these as separate modules, requiring developers to manually script when and why an agent should speak. This "motivation gap" often leads to brittle systems where agents fail to communicate critical information unless specifically programmed to do so. The STAPLE architecture addresses this by deriving dialogue directly from an agent's mental state and its commitments to team goals. If an agent is committed to a team goal, the theory of Joint Intentions dictates that it must communicate whenever it gains new information that affects the team’s success.
The STAPLE Architecture
The core of the system is the STAPLE engine, which integrates several key components to manage teamwork and communication.
The architecture includes a multi-stack BDI interpreter that tracks Persistent Goals (PGOALs) and Joint Persistent Goals (JPGs). It treats teamwork as a formal commitment: agents must stay committed to a goal until it is achieved, impossible, or irrelevant—and they are logically bound to inform their teammates if any of those conditions change. Communication is treated as a "primitive action" with specific preconditions; for example, an INFORM act is triggered only when an agent believes a teammate lacks essential information.
Formal Belief Reasoning
To support complex teamwork, agents must reason about their own beliefs and those of their teammates. STAPLE employs a Horn-clause logic engine based on weak S5 semantics to handle these modal logic operations.
This reasoner allows agents to maintain "Mutual Belief," the foundational element of joint intentions. The technical implementation uses a hybrid approach: Java handles procedural tasks like stack management and the GUI, while Prolog handles the logical reasoning. This integration resulted in a 70-fold performance increase compared to a pure Java implementation, making the system viable for real-time use.
Evaluation: The Lights World
The architecture was evaluated using the "Lights World" domain, a simulation where a human (Bob) and a robot (Harry) must collaborate to turn on a series of lights. The simulation tested various initial conditions—such as who can see the lights and who has the physical capability to flip specific switches—to see if the agent generates the correct dialogue to bridge those gaps.
Key Results and Insights
- Dialogue as a Byproduct: Dialogue is not explicitly programmed; it emerges from intentions. When an agent realizes it lacks information necessary for a joint plan, its internal logic automatically generates a question (e.g.,
ASK-REF) to satisfy its commitment. - Emergent Behavior: In tests, the agent successfully initiated sub-dialogues to identify actors ("Who will switch on Red light?") and reported status updates based solely on its reasoning about the team's state.
- Declarative Teamwork: This approach significantly reduces development time. Instead of writing complex state machines for every possible conversation, developers specify high-level plans and let the STAPLE engine handle the coordination overhead.
Limitations and Future Work
While STAPLE successfully generates functional dialogue, the current version struggles with the nuances of timing when an agent adopts conflicting intentions. Future research will focus on incorporating "plan recognition" to allow agents to infer human intent and exploring probabilistic reasoning to handle uncertainty in "noisy" environments, such as those involving speech recognition errors.
Summary updated