The goal of this project is to develop a general-purpose simulator for a multi-agent system.
Client: Prof. Keith DeckerAn intelligent agent is a persistent entity capable of flexible, autonomous action in some environment. "Flexibility" includes proactive, reactive, and social behavior:
Examples of real-world agents and their actions and goals include:
Researchers who study multi-agent systems often do so by modeling and simulation. The goal is typically to investigate how things play out when agents are given particular algorithms to achieve their goals. By simulating those agents in a computational environment, and gathering statistics on the outcomes, one can draw conclusions about the effectiveness of different algorithms.
The goal of this project is to develop a general-purpose simulator for multi-agent systems. You will not be responsible for designing any particular agents, but you will have to define the interface through which agents will communicate with the simulator.
First, there needs to be a simple domain-specific language for describing the tasks that agents can perform. The language will be a simplified version of CTAEMS. A task has a hierarchical structure, i.e., it forms a tree. The leaves of the tree are methods (aka actions): those represent the actual things performed by agents. Actions take some amount of simulated time, and produce some final quality/reward/value.
A non-leaf node in the tree represents a task/goal, and its children are its subtasks. Each non-leaf node is annotated with an operator (Quality Accumulation Function, or QAF), such as "and" (Min), or "or" (Max). An "and" operator indicates that the corresponding task is not complete until ALL of its substasks are. The "or" indicates the task is complete once at least one of its subtasks has completed---these can represent alternatives (take the high road or the low road), or redundancy (either Jim or Jane can complete the task). Other QAFs are possible (e.g., Sum). The design should allow for future expansion.
Non-local effects (NLEs) between tasks include hard relations like task A enables (must come before) task B, or soft relationships like sorting "facilitates" searching (one task makes another faster, or higher quality).
The simulator will essentially act as a sever whose clients are the agents. The simulator reads a file describing the tasks to be simulated. The simulator sends a message to the agent like "here are the task structures you know about". An agent will send a message (via a socket) to the simulator saying something like "I am now going to start executing method X". The agent will wait for a response from the simulator telling it how long it took to execute X and what the final quality was.
Agents will also be able to communicate with other agents by going through the simulator.
The simulator will gather statistics from a simulation, such as the final quality achieved for each task, the number of messages each agent sent, the amount of work each agent did, etc., and report these at the end.