Designing generic and agent-independent interactions is not easy. Indeed, every interaction has parts, which description depends on the agents that interact. Yet, even if interaction have agent specific elements, their overall semantic might be similar.

To cope with this issue, IODA upholds that interactions manipulate abstract and agent-independent primitives, instead of directly manipulating agent states. These abstract primitives are declared in interactions as factory methods that the agents have to implement.

For instance, the isHungry() primitive of Fig.1(b) can be implemented in agents as:

• To have its energy under a particular threshold
• To have not eaten the last four days
• To have a stress attribute over a particular threshold
• To have not smoked the last hour, etc.

Agents involved in an interaction generally do not play the same function. Difference is made between agents that initiate the interaction -- for which the participation in the interaction comes from their own action selection process -- and agents that undergo the interaction -- which are chosen by the action selection process of source agents.

Illustration of how an interaction between agents is considered as possible.

This figure tells that a woodcutter agent can be the source of the Cut and Open interactions, and can be the target of the Fall and the Kill interaction. The tree agent can be the source of the Fall interaction, and can be the target of the Burn, Cut and the Break interactions. Consequently, the Woodcutter might be able to cut trees (this interaction is represented by an arrow).

Fig.2: Illustration of how an interaction between agents is considered as possible.

The cardinality of an interaction defines how many source and target agent participate in the interaction:

Complex problems may require to define particular situations like the interaction of an agent with itself -- for instance to Rest -- or with the environment -- for instance to Move or to Die. Calling them interaction may seem questionable since they involve a single agent -- i.e. their cardinality is (1,0). Yet, their structure is identical to regular interactions, and they do have an implicit target. Thus, to make the definition of agents abilities homogeneous, such elements are called degenerate interactions.

In order to participate in an interaction, an agent has to implement a particular set of abstract primitives. Yet, all the agents involved in an interaction do not have to implement the same primitives. To differentiate the primitives that agents have to implement, we introduce the notion of function in an interaction.

Interactions are meant to be re-used in various contexts, potentially by different designers. Since the aim of the different primitives cannot always be deduced thanks to their name, each function has to provide a documentation to each primitive it contains.

Consequently, an interaction has to define as many functions as its cardinality states.

In this page, we focus on interactions, which cardinality is either (1,0) or (1,1). In such cases, at most two functions have to be defined: the Source function (i.e. the primitives that the source agent has to implement), and the Target function (i.e. the primitives that the target agent has to implement).

Thanks to all the elements defined above, the formal definition of an interaction is as following:

An agent does not interact with any other agent: it interacts only with agents that are close enough from it. This distance - called limit distance - depends not only on the interaction, but also on the agents that participate in the interaction. For instance, a sheep may Eat grass agents only at a distance of 0 (only at their feet), but a chameleon may Eat insect agents at a greater distance thanks to its tongue. Consequently, a cell of the matrix does not contain interactions, but assignation elements.

In IODA, difference is made between agent instances and agent families.

During simulation, interactions occur between agent instances. Yet, it is their agent families that define what they are able to initiate or undergo. Thus, the interaction matrix specifies what instances of particular agent families are able to initiate together with instances of particular agent families as target.

An assignation represents a cell of the interaction matrix.

An interaction matrix illustration on a toy problem is provided on Figure 3. This matrix defines the possible interactions between entities in an ecosystem simulation, where the different species are Grass, Sheep, Goat and Wolf.

An agent does not interact with any kind of agents: it interacts only with the agents it perceives. In IODA, the perception process is defined thanks to the notion of halo. An agent perceives only its neighborhood -- i.e. the agents that are present into its halo.

The description of agents halo depends on what kind of environment is used in the simulation. In most cases, the halo defines in what subset of the environment agent are perceived. This halo depends of the nature of environments topology:

• a surface in a two dimensional space;
• a volume in a three dimensional space;
• acquaintances in a contact network, etc.

The Halo can also include agents within the memory of perceiving agent.

Because the definition of the halo is domain-dependent, IODA does not constrain its specification. Moreover, IODA does not make any assumption on the environment used in the simulation, as long as a distance can be expressed in it (in order to define the limit distances in the interaction matrix).

The set of interactions an agent can perform in a particular context depends on both its abilities -- i.e. what interactions it is able to initiate with target agent families -- and on the agents that lie in its neighborhood.

This set is called realizable tuples set. A realizable tuple represents either:

• a degenerate interaction, which conditions hold true for the source agent;
• or a couple containing an interaction and a target agent, such that the conditions of the interaction hold true for the source agent and target agents;

Realizable tuples census is part of the algorithms available in the IODA project. More details are provided on this page.

Interaction selection consists in selecting from the realizable tuples of a source agent the one that represents the interaction it initiates. The modalities of this selection depend on whether the agent is a cognitive, hybrid, or reactive one.

IODA is compatible with any interaction selection processes.

The specification of the behavior of reactive agents is described on this page.

The state of agents may evolve independently from the interactions in which they participate. For instance, an agent may grow old, a pheromone have its concentration dropping, etc. In IODA, such a process is defined by agents in a primitive called Updating Primitive.

The call to this primitive depends on the time representation used in the simulation -- i.e. depends on the scheduler used in the simulation. An algorithm presenting its call in the case of discrete time is presented on this page.

Like the halo, the specification of agents updating process is domain-dependent.

Thanks to all the elements defined above, in IODA, agents and agent families follow a simple architecture, which makes possible to design homogeneously agents with different specificities in the same simulation.

The interaction matrix is a whole only during model specification. In practice, the interaction matrix lines are dispatched between the different source agent families.

The structure of agents is highly customizable: their halo can be changed independently from what they are able to do, or their interaction matrix line can be defined independently from their interaction selection process, etc.