EASSS 2012 Overview of Agent-Oriented Programming
Slides of the overview on agent-oriented programming presented at the European Agent Summer School 2012 in Valencia can be downloaded here.
Plugin for Netbeans available
A plugin for Netbeans for GOAL is available now. This plugin supports more advanced editing of GOAL programs. For debugging, the existing debug environment is still used. See the Plugin's project page for more information on installing and using the plugin.
GOAL Interpreter Analyzed by Software Improvement Group
The Software Improvement Group provides tools to analyze source code quality and analyzed the Java code written for the GOAL interpreter. See: here for more details.
We Won the Multi-Agent Programming Contest 2011!!
The Delft team using GOAL has won the Multi-Agent Programming Contest 2011 out of 9 contesters. Other participants came from Argentina, Denmark, Germany, Iran, and Ireland. We won every simulation game! A student team of 6 has been programming the winning multi-agent system in GOAL throughout August.
This year's contest involves a scenario of exploration and exploitation on Mars, where each team has 10 agents to control in the game and the team that scores most exploration and achievement points wins. Our team uses a fully decentralized strategy and is programmed in 100% pure GOAL ;-).
See http://www.multiagentcontest.org for more information on the contest and the other participants.
v3883 of GOAL Released
In this release, logging of a run of a mas to file has been added, the model checker has been enabled again (allows model checking single GOAL agents), and the semantics of the exit-module action has been changed. The exit-module action no longer is counted as a 'real' action and deliberation on performing an action continues after this action has been performed now. Additionally, a break action supports quiting a nested if statement ({...}) and exit-all is added for exiting all active modules. Go here to download the release.
Content
- The GOAL Agent Programming Language
- GOAL Releases and Download
- Documentation
- Developer Resources
- Projects
- Education and Tutorials
- Frequently Asked Questions
- Contact
The GOAL Agent Programming Language
GOAL is an agent programming language for programming rational agents. GOAL agents derive their choice of action from their beliefs and goals. The language provides the basic building blocks to design and implement rational agents. The language elements and features of GOAL allow and facilitate the manipulation of an agent's beliefs and goals and to structure its decision-making. The language provides an intuitive programming framework based on common sense notions and basic practical reasoning.
Overview
The main features of GOAL are:
- Declarative beliefs: Agents use a symbolic, logical language to represent the information they have, and their beliefs or knowledge about the environment they act upon in order to achieve their goals. This knowledge representation language is not fixed by GOAL but, in principle, may be varied according to the needs of the programmer.
- Declarative goals: Agents may have multiple goals that specify what the agent wants to achieve at some moment in the near or distant future. Declarative goals specify a state of the environment that the agent wants to establish, they do not specify actions or procedures how to achieve such states.
- Blind commitment strategy: Agents commit to their goals and drop goals only when they have been achieved. This commitment strategy, called a blind commitment strategy in the literature, is the default strategy used by GOAL agents. Rational agents are assumed to not have goals that they believe are already achieved, a constraint which has been built into GOAL agents by dropping a goal when it has been completely achieved.
- Rule-based action selection: Agents use so-called action rules to select actions, given their beliefs and goals. Such rules may underspecify the choice of action in the sense that multiple actions may be performed at any time given the action rules of the agent. In that case, a GOAL agent will select an arbitrary enabled action for execution.
- Policy-based intention modules: Agents may focus their attention and put all their efforts on achieving a subset of their goals, using a subset of their actions, using only knowledge relevant to achieving those goals. GOAL provides modules to structure action rules and knowledge dedicated to achieving specific goals. Informally, modules can be viewed as policy-based intentions in the sense of Michael Bratman.
- Communication at the knowledge level: Agents may communicate with each other to exchange information, and to coordinate their actions. GOAL agents communicate using the knowledge representation language that is also used to represent their beliefs and goals.
Agent Programs
A GOAL agent program is a set of modules which consist of various sections including the knowledge, beliefs, goals, a program section that contains action rules, and action specifications. Almost all sections are optional. Each of these sections is represented in a knowledge representation language such as Prolog, Answer set programming, SQL (or Datalog), or the Planning Domain Definition Language, for example. Below, we illustrate the components of a GOAL agent program using Prolog.
The overall structure of a GOAL agent program looks like:
init module {
<sections>
}
main module{
<sections>
}
event module{
<sections>
}
<other user-defined modules>
The GOAL agent code used to illustrate the structure of a GOAL agent is an agent that is able to solve Blocks World problems. We first provide the sections that define the agent's initial mental state. These sections should be included in the init module above. The beliefs of the agent represent the current state of the Blocks World whereas the goals of the agent represent the goal state. The knowledge section listed next contains additional conceptual or domain knowledge related to the Blocks World domain.
knowledge{
block(a), block(b), block(c), block(d), block(e), block(f), block(g).
clear(table).
clear(X) :- block(X), not(on(Y,X)).
tower([X]) :- on(X,table).
tower([X,Y|T]) :- on(X,Y), tower([Y|T]).
}
Note that all the blocks listed in the knowledge section reappear in the beliefs section again as the position of each block needs to be specified to characterize the complete configuration of blocks.
beliefs{
on(a,b), on(b,c), on(c,table), on(d,e), on(e,table), on(f,g), on(g,table).
}
All known blocks also are present in the goals section which specifies a goal configuration which reuses all blocks.
goals{
on(a,e), on(b,table), on(c,table), on(d,c), on(e,b), on(f,d), on(g,table).
}
A GOAL agent may have multiple goals at the same time. These goals may even be conflicting as each of the goals may be realized at different times. For example, an agent might have a goal to watch a movie in the movie theater and to be at home (afterwards).
In GOAL, different notions of goal are distinguished. A primitive goal is a statement that follows from the goal base in conjunction with the concepts defined in the knowledge base. For example, tower([a,e,b]) is a primitive goal and we write goal(tower([a,e,b]) to denote this. Initially, tower([a,e,b]) is also an achievement goal since the agent does not believe that a is on top of e, e is on top of b, and b is on the table. Achievement goals are primitive goals that the agent does not believe to be the case and are denoted by a-goal(tower([a,e,b]). It is also useful to be able to express that a goal has been achieved. goal-a(tower([e,b]) is used to express, for example, that the tower [e,b] has been achieved with block e on top of block b. Both achievement goals as well as the notion of a goal achieved can be defined:
a-goal(formula) ::= goal(formula), not(bel(formula)) goal-a(formula) ::= goal(formula), bel(formula)
There is a significant literature on defining the concept of an achievement goal in the agent literature.
The program section below specifies a strategy for selecting actions by means of action rules. This section should (is best) included in the main module. The first rule below states that moving block X on top of block Y (or, possibly, the table) is an option if such a move is constructive, i.e. moves the block in position. The second rule states that moving a block X to the table is an option if block X is misplaced.
main module{
program{
if a-goal(tower([X,Y|T])), bel(tower([Y|T])) then move(X,Y).
if a-goal(tower([X|T])) then move(X,table).
}
}
An events module specifies rules for processing percepts received from the environment. The rule below specifies that if a percept is received that block X is on block Y, and X is believed to be on top of Z unequal to Y, the new fact on(X,Y) is to be added to the belief base and the atom on(X,Z) is to be removed.
event module{
program{
forall bel(percept(on(X,Y)), on(X,Z), not(Y=Z)) do insert(on(X,Y), not(on(X,Z))).
}
}
Finally, we need to provide the agent with actions, in the case of the Blocks World we use only the move action. Actions, such as the move action used above, are specified using a STRIPS-style specification of preconditions and postconditions. A precondition specifies when the action can be performed (is enabled). A postcondition specifies what the effects of performing the action are. As this action needs to be globally accessible, the action specification needs to be included in the init module.
actionspec{
move(X,Y) {
pre{ clear(X), clear(Y), on(X,Z), not(X=Y) }
post{ not(on(X,Z)), on(X,Y) }
}
Development Environment
GOAL is actively being developed and the developments of the language can be tracked on this site. The Roadmap indicates our current plans for developing GOAL. On these pages, if you have the appropriate rights, you can also browse the source code and view and create tickets.
Various wiki pages provide information on different aspects of the GOAL platform, including topics such as releases of GOAL, creating an installer, information on available environments, etc. These pages also document past and current developments.
Other Agent Programming Languages and Platforms
There are many other agent programming languages. More information on some of these languages can be found here.
GOAL Releases and Download
Check available releases and downloads for GOAL. You can download an installer for installing GOAL on your machine.
Installation and Compatibility
The installer is multi-platform, and runs on Windows, Linux and Mac OSX; only 64-bit is supported (older versions of GOAL do run on 32-bit). It requires that Java version 1.6 or higher is installed. The entire installation is local to the directory of your choice. GOAL has been tested using Sun Java and successfully run on the following platforms:
- Windows 7
- OSX Snow Leopard: OSX10.6.2 and higher
- Linux Ubuntu Karmic
Older and some other versions of these operating systems may also work but are no longer officially supported. We have, for example, been able to run on Windows XP and Windows Vista, Linux Debian Etch, Ubuntu Hardy, openSuse 10.3.
Note that some environments may require the installation of additional third party software. For example, the Blocks World environment that is distributed with GOAL requires Java3D. Please check the readme file or documentation that comes with an environment for detailed information.
Documentation
The GOAL Programming Guide introduces the agent programming language GOAL. It illustrates the language and its programming constructs by means of various examples, and discusses how agents interact with environments and each other. The GOAL User Manual introduces the GOAL Integrated Development Environment (IDE) and its features. To effectively use the GOAL IDE in order to develop a GOAL multi-agent system this manual is essential reading material! In the overview of supported SWI Prolog operators you can find which SWI Prolog operators can be used for developing a GOAL agent.
For a translation of this page in the Serbo-Croation language, please see http://science.webhostinggeeks.com/cilj-goal-agent-programski.
Developer Resources
Projects
Research
Research on agent programming involves studying agent programming languages and their features, their use in practice, and research into integrating various techniques such as planning and learning into these languages that are needed for developing effective agents. We provide a brief personal outline of a research agenda and research topics that we believe are important for progressing the field.
Fundamental and basic research questions:
- What kind of expressiveness do we need in AOP? Or, what language elements and features are needed?
- Which language elements and features of agent programming languages are actually used? Is the meaning of the language elements provided in agent programming languages clear to their users, i.e. programmers? Which methods for agent program design are effective? Which tools are needed to develop agent programs?
- How can we verify that agent programs are correct? Can we use e.g. temporal logic combined with belief and goal operators to prove that agents are correct? Which techniques and tools are most effective for proving correctness? Which testing and debugging approaches are most effective?
Short-term important research questions:
- Planning: Combining reactive, autonomous agents and planning.
- Learning: How can we effectively integrate e.g. reinforcement learning into AOP to optimize action selection?
- Debugging: Develop tools to effectively debug agents, mas(!). Raises surprising issues: Do we need agents that revise their plans?
- Teamwork: What are effective mas structures to organize communication, coordination, cooperation between multiple agents?
And, last but not least, to address these questions we need to actually develop applications and take account of the lessons learned. Of course, what is most needed then is to share these experiences and lessons learned!
The projects page provides an overview of various ongoing and completed projects related to GOAL. Examples of such projects include research on extending GOAL with e.g. planning and learning capabilities, using GOAL to control robots, and, for example, empirical research on agent programming.
MSc Students
The projects page also contains information about projects available for master students that want to do a MSc Thesis related to GOAL.
Education and Tutorials
GOAL has been used in a number of courses, aimed at BSc students and MSc students, as well as in tutorials for PhD students. Each of these courses consists of lectures based on slides and on hands-on practical assignments. More details and some materials can be found here.
Frequently Asked Questions
See FAQ.
Contact
You can keep us up to date of your needs, let us know if you have any questions, and help us to improve the GOAL platform.
If you want to report a problem, please mail us the version of GOAL you are using, the mas and agent files, console info [always check the console tabs!], and any other information about the problem you encountered. Also have a look at the ''Frequently Asked Questions''.
For any questions, suggestions, or requests, contact us at: goal@mmi.tudelft.nl.
Join the GOAL Project
If you want to register as a user and get access to other content, then use the register button at the top of this page or send a mail.
Attachments
-
GOAL_IDE.png
(100.7 KB) - added by koen
2 years ago.
-
GOAL.pdf
(0.9 MB) - added by koen
2 years ago.
GOAL Programming Guide (Draft)
