The Agent Modeling (AM) actions take domain actions and speech acts as objects: the idea is that an agent who is performing a problem solving activity to obtain his goals can plan both domain and linguistic actions, according to what is better in the specific situation Ardissono-etal:96a.
Figure 1 shows a portion of the metalevel library: as it can be seen, most of the AM actions have a ``source'' parameter (denoted as s) that represents the agent for whom the action is performed (i.e. its beneficiary). When an agent acts on his own, this parameter is bound to the agent himself; in general, source is used to model team cooperation. The actions are represented in the figure with the following graphical notation:
- specific actions are related to more general ones by means of thick arrows, labeled with the restriction on their executability which distinguishes a specific action from its alternatives (e.g. ``agent(action)=a'');
- the links in the Decomposition hierarchy are represented by boxed multiple arrows (the oval below ``Cycle-do-action'' represents a cyclic decomposition that is executed while the associated condition is true). Dashed lines denote conditional steps which are executed only when their ``if'' condition is true; the ``wh'' restrictions specify when an action can be a step of an higher-level one;
- the notation ``[ x <-]'' means that variable x is assigned a value as a result of the execution of the action to which the notation is associated.
The main AM action (``Satisfy(a, s, g)'') describes the problem solving behavior of an agent a who wants to satisfy a goal g which he has committed to. Briefly, the agent looks for a plan which leads to g (this involves finding some actions - ``Find-actions'' - and exploring them hierarchically - ``Explore-actions'', if they are complex). Then, he chooses between two alternative behaviors: executing it by himself (``Self-act''), or inducing another agent to perform it (``Other-act''). After that, he checks whether the action has been executed successfully by its agent (who can be himself, or his partner): step ``Satisfy(a, a, Knowif(a, done(x, action)))'' describes this behavior (the ``done'' operator maps an action on the world state after a successful execution of the action). If the action was performed successfully and the agent is cooperating with another agent, he notifies the partner about the success (see the conditional step in the recipe). Instead, given that the execution can fail, the agent could loop in this activity (``Cycle-do-action''), by choosing another alternative for g and trying it. Finally, if none of the alternatives could be completed successfully and the agent is cooperating with another agent, he informs his partner that the main goal g is impossible.
Figure 1: A portion of the AM plan library (the ``Satisfy'' plan).
The other major Agent Modeling action is ``Try-execute(a, s, action)'' (not shown in the figure), which describes the process of executing an object level action: when an agent is committed to performing an action, he first checks whether its constraints and preconditions are satisfied (this is described by an occurrence of the ``Satisfy'' action in the body of ``Try-execute''); if the preconditions of the action are not satisfied, the agent can adopt them as subgoals. Then, if the action can be executed, he moves to its performance, or to the execution of its steps, if it is complex. At end, he has to check if the effects of the action hold, in order to know if he has succeeded; on the contrary, if the action can not be executed (because its constraints are false), the agent can inform the partner of the problem (see the notion of Joint Intention in agent cooperation introduced in [Cohen & Levesque1991]).
Our agent model is a ( Belief, Desire, Intention) BDI agent
Rao-Georgeff:91. The notion of commitment adopted in our model
follows the notion of intention and Joint Intention described in
[Cohen & Levesque1990a], [Cohen & Levesque1990b],
[Cohen & Levesque1991], as derived from the original description of
intention given in [Bratman1990].
The agent's behavior is ruled by a core interpreter which loops on three
phases: the interpretation of the input, the decision of which high-level goal
to commit to (on the basis of which is the internal state of the agent), and
the reaction, where the agent starts acting to reach the chosen goal (by means
of the execution of a ``Satisfy'' action on the goal).
In our current implementation, the agent works only in the interpretation mode,
so the system plays the role of the hearer for each turn of a conversation, by
switching his role among the two interactants and letting the human user play
the role of the ``speaker'' and type sentences on the keyboard.