wiki:WikiStart
Last modified 4 weeks ago Last modified on 03/19/14 15:17:46

GOAL News

A Unit Testing Framework for GOAL

A new unit testing framework for GOAL has been released. Tests can be run both from within Eclipse, using the plugin, as well as from the command line. Check out the GOAL Programming Guide and Projects/UnitTesting for more about the framework itself.

  • Posted: 2014-02-09 14:03 (Updated: 2014-02-09 23:55)
  • Author: koen
  • Categories: (none)
  • Comments (0)

Eclipse Plugin Released

We have released a plugin for Eclipse that allows creating, managing, and running GOAL projects.

The plugin makes the usual support that Eclipse provides available for creating, editing, and managing projects, including, e.g., the use of svn. When running a MAS still a dedicated environment for debugging GOAL MAS is launched. We will continue working on integrating the debugging environment into Eclipse in the coming months.

Information on how to install it is available here. Additional information about the development of this plugin can be found here.

  • Posted: 2014-02-06 15:25 (Updated: 2014-02-06 21:08)
  • Author: koen
  • Categories: (none)
  • Comments (0)

Work in progress to make Eclipse plugin available

We're working hard currently to make an Eclipse plugin for GOAL available. We're aiming for an initial release on February 10th. That release should make a GOAL perspective for Eclipse available which includes all the benefits of the Eclipse code editing environment. The release will still provide the custom-made debug environment for debugging. We'll continue to work on this part and release a debugging environment integrated in Eclipse available later. See also the page on the Eclipse plugin project.

  • Posted: 2014-01-17 11:38 (Updated: 2014-01-17 11:38)
  • Author: koen
  • Categories: (none)
  • Comments (0)

EASSS 2013 Overview of Agent-Oriented Programming

The slides of the first lecture of the tutorial on Agent-Oriented Programming can be found here

  • Posted: 2013-07-06 09:28
  • Author: koen
  • Categories: (none)
  • Comments (0)

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.

  • Posted: 2012-05-31 17:11
  • Author: koen
  • Categories: (none)
  • Comments (0)

Content



  1. GOAL Releases
  2. The GOAL Agent Programming Language
  3. Documentation
  4. Education and Tutorials
  5. Projects
  6. Frequently Asked Questions
  7. Developers Pages
  8. 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.


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.


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@ii.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