wiki:WikiStart
Last modified 5 weeks ago Last modified on 09/22/14 09:05:01

GOAL News

GOALhub and EIShub @ GitHub

We have migrated the Environment Interface Standard (EIS) from sourceforge to GitHub and have started to migrate our own EIS-enabled environments to eishub on GitHub as well to make them more accessible. We have also started a similar effort for GOAL, where some initial effort to start using goalhub have been made as well. More to come soon, have a look!

  • Posted: 2014-07-31 16:30
  • Author: koen
  • Categories: (none)
  • Comments (0)

EASSS 2014

We have given a tutorial on agent programming at EASSS 2014 in Crete! Follow the link http://ii.tudelft.nl/trac/goal/wiki/Education/EASSS2014 to download the presentation on GOAL and the exercise and software that we used.

  • Posted: 2014-07-15 06:51 (Updated: 2014-07-21 07:01)
  • Author: koen
  • Categories: (none)
  • Comments (0)

Vacancy Self-Explaining Cognitive Agents

We are looking for excellent candidates that have received an MSc degree in Artificial Intelligence or Computing Science. Candidates that have experience with cognitive agent technology or more specifically with agent-oriented programming, and/or automated explanation are invited to apply for this position. Candidates should have excellent Java programming skills and preferably a strong background in software engineering. Ideally, the candidate also has experience with user evaluation of software tools.

See: http://ii.tudelft.nl/?q=node/7646 for more info, or mail: k.v.hindriks@tudelft.nl.

  • Posted: 2014-07-08 09:14 (Updated: 2014-07-08 09:14)
  • Author: koen
  • Categories: (none)
  • Comments (0)

Q&A for GOAL

A new Q&A site for GOAL has been created where questions can be posted related to programming in GOAL, writing agent programs, using development tools, debugging agents, environments that agents are connected with, etc. The benefit of using a Q&A site is that everyone can benefit from sharing the answers provided!

  • Posted: 2014-06-30 15:50 (Updated: 2014-10-14 18:33)
  • Author: koen
  • Categories: (none)
  • Comments (1)

Fully Integrated Development Environment for Eclipse Released

We have just released a major update of the GOAL Plug-in for Eclipse. This update now provides a fully integrated code writing and debugging environment in Eclipse for GOAL. A main feature of the debugging perspective is that it also provides code stepping for agent programs.

The plug-in is made available for Eclipse Kepler. Check out the instructions for installing the plug-in. A Quick Start Guide is available which briefly explains debugging agent programs in Eclipse and the main new features, including:

  • code-stepping with display of rule condition and precondition evaluation
  • breakpoints for (conditionally) breaking on a rule in a program
  • introspector for inspecting beliefs, goals, percepts, and mails of an agent
  • evaluation for displaying evaluation of current rule condition or action precondition
  • interactive console for querying an agent's mental state
  • history logs that display complete history of an agent's run
  • Posted: 2014-05-26 20:26
  • Author: koen
  • Categories: (none)
  • Comments (0)

Content



  1. Download GOAL
  2. The GOAL Agent Programming Language
  3. Documentation
  4. Questions & Answers related to GOAL
  5. Education and Tutorials
  6. Projects
  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:

  • Programming with mental states: Different from most other programming languages, GOAL supports programming at the knowledge level. Programming an agent means to program with the mental state of that agent. A mental state consists of declarative knowledge, beliefs and goals.
    • Agents use a knowledge representation language (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.
    • 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.
    • 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. 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.
    • The type of knowledge representation language is not fixed by GOAL but, in principle, may be varied according to the needs of the programmer.
  • Programming decision strategies: Programming an agent means to code a strategy or policy for action selection. Agents use action rules to select actions, given their beliefs and goals. The type of decision making supported in GOAL is directly based on human common sense decision making, which also decide and explain their choice of action using beliefs and goals.
  • Abstract Actions, Learning, and Planning: The decision making rules can be grouped together in modules which can be viewed as abstract actions. This allows for adding hierarchical structure to an agent program and to encapsulate decision logic in re-usable modules. This way agents can focus their attention and put all their efforts on achieving a subset of their goals, using a subset of their actions, and using only knowledge relevant to achieving those goals. The decision making of an agent can be underspecified which means that the choice of action does not pinpoint a single action but allows for multiple options that can be performed. This underspecification can be exploited by a learning mechanism that optimizes the behaviour of a GOAL agent. Action rules may also be used to guide a planner that uses the action specifications that are part of the agent program to construct a plan of action.
  • 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(X) :- on(X, _).
  clear(table).
  clear(X) :- block(X), not(on(_ ,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

Eclipse IDE

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.


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