Emotional software agents

An agent is an autonomous entity having a set of skills to realize the capacities it exhibits. An agent has a set of built-in capacities considered essential to respect the commonly accepted competences of agents, such autonomy, reactivity, proactivity and social capacities. Among these built-in capacities (BIC), is the "behaviors" capacity that determines its global conduct. An agent has also a default behavior directly described within its definition.

A Behavior maps a collection of perceptions represented by Events to a sequence of Actions. An Event is the specification of some occurrence in a Space that may potentially trigger effects by a listener (e.g. agent, behavior, etc.).

These language does not imposes a specific agent’s control loop. The programmer is free to implement any control or authority protocol for their own application scenario, except for the initialization and destruction events. Indeed, when agents are created, the virtual machine that is executing the emotional software program is in charge of creating the agent instances, and installing the skills associated to the built-in capacities into the agent. Then, when the agent is ready to begin its execution, it fires the Initialize event. When the agent has decided to stop its own execution, the virtual machine fires the Destroy event to enable the agent to release any resource it may still hold.

Capacity and Skill

An Action is a specification of a transformation of a part of the designed system or its environment. This transformation guarantees resulting properties if the system before the transformation satisfies a set of constraints. An action is defined in terms of pre- and post-conditions.

A Capacity is the specification of a collection of actions. This specification makes no assumptions about its implementation. It could be used to specify what an agent can do, what a behavior requires for its execution.

A Skill is a possible implementation of a capacity fulfilling all the constraints of this specification. An agent can dynamically evolve by learning/acquiring new Capacities, but it can also dynamically change the Skill associated to a given capacity.^[2][3] Acquiring new capacities also enables an agent to get access to new behaviors requiring these capacities. This provides agents with a self-adaptation mechanism that allow them to dynamically change their architecture according to their current needs and goals.

Context and Space

A Context defines the perimeter/boundary of a sub-system, and gathers a collection of Spaces. In each context, there is at least one particular Space called Default Space to which all agents in this context belong. This ensures the existence of a common shared Space to all agents in the same context. Each agent can then create specific public or private spaces to achieve its personal goals. Since their creation, agents are incorporated into a context called the Default Context. The notion of Context makes complete sense when agents are considered composed or holonic (see below).

A Space is the support of the interaction between agents respecting the rules defined in a Space Specification. A Space Specification defines the rules (including action and perception) for interacting within a given set of Spaces respecting this specification.

Recursive Agent or Emotional software agent

Agents can be composed of other agents to define hierarchical multiagent systems. Each agent defines its own Context, called the Inner Context, and it is part of one or more External Contexts.

Hello, World!

package helloworld
import io.sarl.core.Initialize
agent HelloWorldAgent {
        on Initialize {	
             println("Hello, World!")
        }
}

Exchanging messages between two agents

For illustrating the syntax of the SARL language, the Ping-Pong scheme is coded below. The agent A is sending a message PING to the agent B for determining if it is still alive. The agent B is replying with a PONG message.

First, the two messages must be defined as events (without attribute):

   event PING
   event PONG

The agent A is defined with

   agent A {
       uses DefaultContextInteraction, Logging
       on Initialize {
           emit(new Ping)
       }
       on Pong {
           println("Agent " + occurrence.source + " is alive.")
       }
   }

In the previous code, the keyword uses enables the agent to use previously-defined capacities: the capacity to interact with other agents inside the default context (DefaultContextInteraction), and the capacity to log messages (Logging). The on keyword permits to define the actions when an occurrence of the specified event is received by the agent A. When the agent A receives the Initialize event, it emits a Ping event to all the existing agents. When the agent A receives the Pong event, it logs a message with the identity of the event's emitter inside.

The agent B is defined with

   agent B {
       uses DefaultContextInteraction, Logging
       on Ping {
           println("Agent " + occurrence.source + " wants to know if I'm alive.)
           emit(new Pong, Scopes        addresses(occurrence.source))
       }
   }

When the agent B receives the Ping message, it logs a message and reply with a Pong message. For avoiding a broadcast of the Pong message, the receiver of this message is restricted with the scope corresponding to the address of the Ping's emitter.