Operational Semantic of an AgentSpeak(L) Interpreter Using Late

Bindings

Frantisek Vidensky

, Frantisek Zboril

, Radek Koci

and Frantisek V. Zboril

Department of Intelligent Systems, Brno University of Technology, Bozetechova 2, Brno, Czech Republic

Keywords:

BDI Agents, Operational Semantics, AgentSpeak(L).

Abstract:

Although BDI systems have long been studied in the ﬁeld of agent-based programming, there are still problems

open for research. One problem is that some parts of systems are non-deterministic in the original speciﬁcation.

However, ﬁnding a suitable deterministic method can lead to improved rationality of an agent’s behaviour.

In our previous work, we introduced late binding into the interpretation of AgentSpeak(L) language. The

main beneﬁt of this approach is that the interpreter chooses substitutions only when needed, thus avoiding

unnecessary and incorrect substitution selection. In this paper, we present a formal operational semantics

for an interpreter using late binding variables. A well-speciﬁed operational semantics is necessary for the

implementation of such an interpreter and its further development.

1 INTRODUCTION

Languages based on BDI paradigms have an im-

portant place in programming agents as autonomous

proactive systems. Currently, one of the basic lan-

guages is AgentSpeak(L) (Rao, 1996) and its dialects,

such as the ASL language for the Jason system (Bor-

dini et al., 2007). In the paper (Rao, 1996), where

the original language was ﬁrst introduced, several se-

lection functions were listed that fulﬁlled their role in

agent control only in the abstract and introduced non-

determinism into agent functionality. In the practi-

cal reasoning phase, these were functions for select-

ing a goal to follow and for choosing between suitable

plans for the selected goal. In the execution phase, it

was a selection function to choose an intention to be

followed in a given cycle. From then to the present,

a number of approaches have been published to ad-

dress these non-determinisms to improve the rational-

ity of the behaviour of such agents. For example, in

(Caillou et al., 2017) the authors presented a cogni-

tive agent architecture based on the BDI paradigm us-

ing priorities in plan selection. In (Nunes and Luck,

2014), softgoals were used to inﬂuence the selection

of a plan to achieve goals. The authors of paper (Wa-

https://orcid.org/0000-0003-1808-441X

https://orcid.org/0000-0001-7861-8220

https://orcid.org/0000-0003-1313-6946

https://orcid.org/0000-0002-6965-4104

ters et al., 2015) introduced two new approaches for

intention selection. The same team of authors in the

paper (Waters et al., 2018) used a partial plan that

does not specify the exact order of operations in the

body of a plan, leading to increasing the agent’s ﬂex-

ibility and robustness. Paper (Yao and Logan, 2016)

introduced the use of the Monte Carlo Tree Search

method to select intention to avoid conﬂicts in con-

currently executing plans.

One additional problem that we believe has not

received as much attention in this system has been

the choice of substitutions during both phases, i.e.,

the reasoning and execution phases. In a similar

BDI system, dMars (d’Inverno et al., 1997), the need

to choose substitutions was also mentioned but also

without detailed methods for choosing them. The

more advanced CAN (Sardina and Padgham, 2011)

system mentions substitutions as options for choosing

plans, which are chosen if the previously chosen plan

instance (i.e., the plan and any substitutions) fails.

In this paper, we want to demonstrate the opera-

tional semantics deﬁning transition relation for inter-

preting the AgentSpeak(L) language using late bind-

ings variables. We introduced this approach in the

(Zboril Jr et al., 2022) paper.

This paper is structured as follows. The following

section gives a very brief overview of AgentSpeak(L)

and its constructs (such as beliefs, goals and plans).

Sections 3 and 4 will describe the fundamental oper-

ations for late binding and its use for interpreting an

Vidensky, F., Zboril, F., Koci, R. and V. Zboril, F.

Operational Semantic of an AgentSpeak(L) Interpreter Using Late Bindings.

DOI: 10.5220/0011620700003393

In Proceedings of the 15th International Conference on Agents and Artiﬁcial Intelligence (ICAART 2023) - Volume 1, pages 173-180

ISBN: 978-989-758-623-1; ISSN: 2184-433X

 2023 by SCITEPRESS – Science and Technology Publications, Lda. Under CC license (CC BY-NC-ND 4.0)

173

agent program. We then present the main contribution

of this work, i.e. the operational semantics for inter-

preting the AgentSpeak(L) language using late bind-

ing variables in Section 5. Future work is discussed

in the last section.

2 AGENT PROGRAM WRITTEN

AgentSpeak(L)

This section will describe the basics of an agent pro-

gram written in AgentSpeak(L). The following text is

based on (Rao, 1996).

The essential element in an agent program is the

agent, which is deﬁned as follows:

An agent is given by a tuple

hPB,EQ,BB,AS,IS,S

i, where PB is a

plan base, EQ is an event queue, BB is a belief base,

AS is a set of actions that are executable by the agent,

IS is a set of intention structures and S

, S

are

events, options and intentions selection functions.

The purpose of an agent is to achieve certain goals.

There are two types of goals: achievement goals and

test goals. Goals are written as !g(t) and ?g(t) re-

spectively, where g is a predicate symbol and t is a

sequence of terms. Achievement goals state that the

agent wants to achieve an environmental state where

the atom representing the goal is true. The test goal

says that the agent wants to test whether there is uni-

ﬁcation with a belief from the base BB, which is a set

of beliefs in the form of literal.

Essential elements of an agent program are plans

that specify how to achieve a goal. Plans are writ-

ten in the form of t

: Ψ ← plan. Each plan consists

of the triggering event t

, context conditions Ψ and

the body of the plan is composed of a sequence of

elements that may be a goal or an action. A trigger

event can be internal (when a sub-goal needs to be

achieved) or external (triggered when the belief base

is updated while observing the environment). Gen-

erally, an event is triggered by adding (preﬁx +) or

removing (-) a belief or a goal.

For clariﬁcation, we mention that beliefs, events

and goals are written as ﬁrst-order logic atomic for-

mulas (atoms). Also, a context condition for a plan is

either atomic formula or a set of atomic formulas in

conjunction.

In each cycle, an event is selected for processing

using the function S

. This event is then uniﬁed with

the triggering events of the plans in the plan base PB.

Plans whose triggering events are uniﬁed are called

relevant plans. Relevant plans, whose context condi-

tions are a logical consequence of the belief base, are

called applicable plans. One of the applicable plans

is then selected using the function S

. This plan is

called a possible means of achieving the goal.

The problem that the system using late variables

binding during interpretation solves is that the substi-

tutions selected in one step may no longer be applica-

ble in the next step. In that case, the whole deliber-

ation cycle would have to be repeated, which can be

a big problem in a very dynamic environment. Our

proposed system uses delayed selection of substitu-

tion until necessary to solve this problem. This prin-

ciple is called late bindings. The basic methods used

in this system are described in the following section.

3 OVERVIEW OF OPERATIONS

AND FUNCTIONS FOR LATE

BINDINGS

As mentioned, in our previous article (Zboril Jr et al.,

2022) we deﬁned operations and functions for late

bindings. For the purpose of completeness, they will

be re-introduced and brieﬂy described in this section.

Uniﬁers and substitutions play an essential role in

late bindings, as they are created and then modiﬁed in

each part of the agent’s interpretation cycle. The pur-

pose of the basic function is to create sets of uniﬁers.

We called this function broad uniﬁcation.

Deﬁnition 1. Broad uniﬁcation, denoted as ρU, is

formally deﬁned as:

ρU(p,PS)

def

== {mgu(p, p

) : p

∈ PS}

maps the atom p and atom p

from the set of atoms PS

to a set of all possible most general uniﬁers without

variables renaming.

The result of a broad uniﬁcation is a set of uniﬁers,

which we call a possible uniﬁer set (PUS). In the fol-

lowing text, we will use the simpliﬁed form ρU for

the broad uniﬁcation of the atom p and a set of atoms.

Deﬁnition 2. The instance set is denoted by Iσ. This

function maps an atom and a PUS to a set of atoms.

This instance set is deﬁned as follows:

Iσ(p,ρU)

def

== {pσ : σ ∈ ρU}

Informally, the instance set contains each atom

that is created after applying each uniﬁer from the

PUS to an atom. It must be noted that the instance

set is not the inverse function of the broad uniﬁcation.

Deﬁnition 3. The Shorting function which we de-

noted ≺, is deﬁned as follows:

ρU ≺ p

def

== {σ : ∃σ

(σ

∈ ρU, σ ⊆ σ

∀[t/x] ∈ σ

(x ∈ Var(p) → [t/x] ∈ σ))}

ICAART 2023 - 15th International Conference on Agents and Artiﬁcial Intelligence

174

The resulting set contains such substitutions that sub-

stitute free variables from p.

The following functions and operations are used to

modify PUSs and play an essential role in late bind-

ings. The ﬁrst is the merging operation. Its purpose is

to create a substitution from two other substitutions.

The operation unites substitutions when each variable

is substituted for the same term in both of them. If a

situation arises where the substitutions map the same

variable to two different terms, the result of the oper-

ation is an empty set.

Deﬁnition 4. The merging operation is denoted as n

and is deﬁned as follows:

n σ

def







∪ σ

iff ∀[t

] ∈ σ

∀[t

] ∈

= x

→ t

= t

)

0 else

Assume that the merging substitutions unify two

different atoms in two belief bases. If the result is

a non-empty set, both substitutions unify both atoms

into the belief bases. Nevertheless, there may be an-

other pair of uniﬁers for which this operation pro-

duces a non-empty set. To ﬁnd such a pair, we deﬁned

the restriction operator.

Deﬁnition 5. We denoted the restriction operator by

u, this operator is deﬁned as:

ρU

u ρU

def

[

∈ρU

,σ

∈ρU

n σ

The result of this operator for two PUS

ρU(p

,BB

) and ρU(p

,BB

) is a set of uniﬁers that

contain all the most general uniﬁers that unify p

the belief base BB

and p

in the belief base BB

To transfer substitutions when moving from one

plan to another, we introduced the PUS intersection

function.

Deﬁnition 6. The intersection function denoted by ∼

for PUS ρU and two atoms p

and p

is deﬁned as

follows:

,ρU ∼ p

def

== ρU (p

,Iσ(p

,ρU))

4 LATE BINDINGS IN

INTERPRETATION OF

AgentSpeak(L)

The reasoning process produces substitutions that are

used in plan selection. It also creates substitutions by

unifying a plan’s triggering event and context condi-

tions with the selected (by the S

selection function)

event to process and the agent’s belief base.

In most BDI systems, substitution must be se-

lected immediately when a plan is selected as a means

to achieve a goal. Nevertheless, the late binding sys-

tem will keep the substitutions separate as a PUS.

We call this PUS context of the plan. This con-

text changes when the agent performs an action or

achieves a goal. The system can also assign context

to events. Plans and events that do not have a selected

substitution but have an associated context are called

weak instances of plans and events.

Deﬁnition 7. A weak plan instance is a triple

hte,h,ctxi, where te is a plan’s triggering event, h =

;...;h

is the plan’s body, and ctx is the plan’s

context.

Similarly, we can deﬁne a weak event instance.

Deﬁnition 8. A weak event instance is a triple

hevt, ix,ctxi, where evt is an event, ix is an identiﬁer

of the intention that raises the event (or null in case of

an external event) and ctx is a context.

We should note here that in the previous paper

(Zboril Jr et al., 2022), the weak event instance was

deﬁned as a tuple, and the identiﬁer of the inten-

tion was missing. This was for simplicity, as we did

not need to distinguish between internal and external

events. However, this will be necessary for this paper,

as you will see later.

The purpose of a weak event instance is to repre-

sent an event that has arisen during the execution of

a weak plan instance. Thus, the context of the cur-

rently executing plan is used to create this weak event

instance.

In the following text, we will use the abbreviation

WPI for weak plan instance and WEI for weak event

instance.

The last deﬁnition in this section will be the deﬁ-

nition of intention.

Deﬁnition 9. The intention is a structure containing

WEIs of a plan’s triggering event and a stack of WPI

plans. Formally, it is deﬁned as follows:

hevt, ix,ctxi[hte

,ctx

i ‡ hte

,ctx

i ‡ ...

‡hte

,ctx

where the top of the stack is on the left.

If we need to shorten the intention notation, we

replace part or all of the stack contents with P. So

hevt, ix, ctxi[hte

,ctx

i ‡ P| is also an intention.

In this and the previous sections the fundamentals

of late binding have been presented, and in the next

section the core of this paper, operational semantics,

will be described.

Operational Semantic of an AgentSpeak(L) Interpreter Using Late Bindings

175

5 OPERATIONAL SEMANTICS

A system using late binding variables performs a pro-

gram written in the AgentSpeak(L) language and in-

terprets it using weak instances. Its functioning can

be described by certain transition rules that specify

its operational semantic (Plotkin, 1981). This is a

common instrument for precise formal speciﬁcation

of system behaviour based on labelled transition rules

which deﬁne the steps in which a system may evolve.

It has been used many times in the area of agent sys-

tems; for example, for AgentSpeak(L) interpretation

in its basic version (Moreira and Bordini, 2002) as

well as in the extended version with speech acts (Mor-

eira et al., 2003), goal dynamic in CAN (Harland

et al., 2014), etc.

Labelled transition rules deﬁne a relation among

an agent’s conﬁgurations.

Deﬁnition 10. Agent conﬁguration is a tuple

hPB,EQ,BB,AS,ISi, where PB is a set of plans, EQ

is an event queue that contains WEIs, BB is a belief

base which consists of ground atoms, AS is a set of

actions, and IS is a set of intentions.

When an agent is executed, it’s running in a se-

quence of conﬁgurations from an initial conﬁgura-

tion to a ﬁnal one. The agent’s current conﬁgura-

tion changes either when it does some reasoning, or

when it executes a plan. Let there be a relation =⇒

AEX

(agent’s execution) that is composed of two relations

=⇒

RSN

(reasoning) and =⇒

ACT

(acting), where the ﬁrst

relation represents the change of the agent’s conﬁgu-

ration during its practical reasoning process and the

second relation represents the agent’s actions. Then

we deﬁne that =⇒

AEX

= ( =⇒

RSN

∪ =⇒

ACT

), which means

that the AEX relation represents both practical rea-

soning as well as acting.

The transition rules for the agent’s execution cover

both these relations. Recall that the agent ﬁrst looks

for a means for a goal event. The means should be a

plan which is relevant to the event, and it is applica-

ble due to an agent’s beliefs about the current environ-

ment. In this paper, we do not consider any advanced

reasoning about event selection; we assume that an

event is selected as the ﬁrst element in the event queue

if the queue is not empty. It differs from the origi-

nal interpretation in the way it recognises applicabil-

ity and relevance.

5.1 Relevant and Applicable Plans

For completeness, here is the deﬁnition of a relevant

and applicable plan in the system. More about practi-

cal reasoning for weak instances can be found in our

previous paper (Zboril Jr et al., 2022).

Assume that there is WEI and a plan p, then the

plan p is relevant to the WEI when the PUS intersec-

tion of its triggering event and the event with context

create a set containing at least one substitution. Note

that this is true even if the substitution is an empty set.

Formally:

Deﬁnition 11. A plan te : b

∧ b

∧ ... ∧ b

←

;...;h

is relevant to a weak event instance

hevt, ix, ctxi when (evt, ctx ∼ te) 6=

For a relevant plan to be applicable, all its context

conditions must be satisﬁed in the belief base. More

concretely, it must be possible to ﬁnd a PUS for each

context condition and belief base and then make the

restriction between them.

Deﬁnition 12. A plan te : b

∧ b

∧ ... ∧ b

←

;...;h

is applicable in the current belief base

BB if it is true that:

ρU(b

,BB) u ... u ρU(b

,BB) 6=

One plan is then selected from the applicable plans

using the selection function S

Any plan that is relevant and applicable can be

considered a means to achieve a goal, and the agent

may choose it as its intended means. If the plan is

both relevant and applicable, then the restriction of

PUSs (contexts) for both WPI and WEI must be a

non-empty PUS. Using the PUS intersection, we can

write:

ctx

= ((evt,ctx ∼ te) u ρU(b

,BB)u

... uρU(b

,BB)) 6=

and then ctx

is a context of a plan which, together

with the plan’s body h

;...;h

, forms a new WPI

that can be an intended means for the WEI.

5.2 Transition Rules

In the following text, we can divide the presented

rules into three groups to deﬁne the relations men-

tioned above. The ﬁrst group deﬁnes the relation =⇒

RSN

using two rules.

The ﬁrst rule (PR − EXT EV T ) is used in situ-

ations when the agent deals with an external event

and the second rule (PR − INT EV T ) is for the case

of an internal event. Both these rules change the

agent’s event queue and intention structure. Both also

compute contexts for relevant and applicable plans,

which can all be an intended means for the event.

Whether the event is internal or external depends on

the form

ICAART 2023 - 15th International Conference on Agents and Artiﬁcial Intelligence

176

PR-EXTEVT

e = hevt,null,ctxi ∈ EQ

p = te : b

∧ ...∧ b

← h ∈ PB

ctx

= ((evt,ctx ∼ te), ρU(b

,BB) u ... u ρU(b

,BB)) 6=

hPB,EQ,BB,AS,ISi =⇒

RSN

hPB,EQ − {e}, BB, AS,IS ∪ {hevt,ix,ctxi[hte,h,ctx

i]}i

PR-INTEVT

e = hevt,ix,ctxi ∈ EQ

p = te : b

∧ ...∧ b

← h ∈ PB

ctx

= ((evt,ctx ∼ te), ρU(b

,BB) u ... u ρU(b

,BB)) 6=

hPB,EQ,BB,AS,ISi =⇒

RSN

hPB,EQ − {e}, BB, AS,(IS − {hevt

,ix,ctx

}i[P]}) ∪ {hevt

,ix,ctx

i[hte,h,ctx

i ‡ P|}i

EXEC1

i = hevt,ix,ctxi[hte

,ctx

i| ∈ IS

hEQ

,BB

,AS

,(ix : h

,ctx

)i → hEQ

,BB

,AS

,(ix : h

,ctx

hPB

,EQ

,BB

,AS

,IS

i =⇒

ACT

hPB

,EQ

,BB

,AS

,(IS

− {i})∪ {hevt,ix,ctxi[hte

,ctx

i|})i

EXEC2

i = hevt,ix,ctxi[hte

,ctx

i ‡ P| ∈ IS

hEQ

,BB

,AS

,(ix : h

,ctx

)i → hEQ

,BB

,AS

,(ix : h

,ctx

hPB

,EQ

,BB

,AS

,IS

i =⇒

ACT

hPB

,EQ

,BB

,AS

,(IS

− {i})∪ {hevt,ix,ctxi[hte

,ctx

i ‡ P|})i

CLEARINT1

i = hevt,ix,ctxi[hte

,null, ctx

i| ∈ IS

hPB,EQ,BB,AS,ISi =⇒

ACT

hPB,EQ,BB,AS,(IS − {i})i

CLEARFAIL1

i = hevt,ix,ctxi[hte

, f ail,ctx

i| ∈ IS

hPB,EQ,BB,AS,ISi =⇒

ACT

hPB,EQ ∪ {hevt,null, ctxi}, BB, AS,(IS − {i})i

of the WEI. When there is no parent intention men-

tioned, better say it is null, then a new intention stack

is created and an intended means is inserted there.

Otherwise, the means are added to the corresponding

intention stack.

If all three conditions above the line are satisﬁed

(null in this rule means that no intention is bound

to the event), then WEI e is removed from an event

queue EQ and a new intention ix is created. This in-

tention is composed of new WEIs hevt,ix, ctxi and a

plan stack that contains WPI hte,h,ctx

i. Note that

te is a triggering event of the chosen plan, h is its

body, and ctx

is the context computed as was shown

in Deﬁnitions 11 and 12.

The PR − INT EV T rule is similar to the previous

one. It differs only in the form of the processed WEI.

The second group of rules deﬁnes the =⇒

ACT

rela-

tion. At the intention level, the agents try to execute

one step for an intention from its intention set (the

intention was created for some WEI hevt

,ix,ctx

i).

There are six rules (EXEC1, EX EC2, CLEARINT 1,

CLEARFAIL1, CLEARINT 2, CLEARFAIL2) that de-

ﬁne how the intention can change when the agent per-

forms the ﬁrst item of its top-level plan. These rules

are used in situations when an intention step ﬁnishes

either successfully or unsuccessfully. If the step was

successful, then there are two separate rules for when

it completes the entire plan, and for when any actions

remain in the body of the plan. We must distinguish

whether the completed plan was a top-level plan of

the intention or a sub-plan within the intention.

All these rules use one more lower-level transition

relation that determines the behaviour of the agent

at the plan level. This transition relation is denoted

as → and represents one step in the plan execution.

The following rules transform n-tuples of the form

hEQ,BB,AS,(ix : h, ctx)i, where EQ, BB and AS are

the same as in Deﬁnition 10. Sets PB and IS are omit-

ted and instead there is a shorted version of an inten-

tion stack that contains its identiﬁer ix, h is the body

of its top-level plan, and ctx is its context.

The EXEC1 and EXEC2 rules are deﬁned for any

non-empty intention stack with a non-empty plan on

top of it. Furthermore, the execution of a plan is as-

Operational Semantic of an AgentSpeak(L) Interpreter Using Late Bindings

177

sumed to lead neither to an empty plan nor to its fail-

ure. The body of the plan should remain in the in-

tention stack, but its body is always truncated by one

item. In addition, other parts within the conﬁguration

may also be changed.

The ﬁrst rule is applicable if the WIP is the only

element of the intention stack, and the second rule is

applicable if there is more than one WIP in the inten-

tion stack.

When the agent completes a sub-plan, the sub-

plan is removed from the intention stack. A sub-plan

is completed when there are no more items in the body

of the plan, which is represented by null. Neverthe-

less, if the plan is the last plan in the intention stack,

then the agent successfully achieves the top-level goal

and the corresponding plan is also removed from the

IS. Failure to complete the plan will result in the re-

moval of the corresponding plan, and moreover, the

WEI must be put back into the EQ.

The situation is a little more complicated when the

agent completes a plan to achieve a goal. Some in-

formation should be transmitted upward to the goal-

setting plan. The just-completed plan contains a con-

text with substitutions corresponding to all the goals

the agent has achieved during execution.

The higher-level plan declared the achievement

goal !g(t

) in the current context ctx

. For this goal, a

plan with trigger event +!g(t

) was chosen. Assume

that this plan has been successfully completed with

a context ctx

. If we create an instance set from the

trigger event g(t2) of the plan and the context ctx

, we

get all the goals that the plan achieved. Using the in-

tersection g(t

),ctx

∼ g(t

),ctx

of the achievement

goal g(t

) in the context ctx

with the triggering event

g(t2) in the context ctx

we obtain a new context ctx

Note that the body of the plan in the ﬁrst line con-

sists of two parts - the abstract part denoted as h

and

then the achievement goal !g(t

). Only the ﬁrst part

of h

remains after this step.

If the plan fails and is not the last plan in the in-

tention stack, then the plan is removed from the stack

and the higher-level plan still contains the achieve-

ment goal.

The third and ﬁnal set of rules deﬁnes the agent’s

behaviour at the plan level.

In the late binding system, the test target is the

only plan item that can fail. Whether it succeeds de-

pends on the result of the restriction of the goal atom,

the current context of the plan, and the current state of

the agent’s belief base. If the result is an empty set, it

means that the plan can continue to execute, and the

set is the new context of the plan.

In case the test goal fails, the whole plan fails.

An achievement goal may cause a new weak event

instance. If there is no corresponding WEI in the

agent’s EQ and the intention stack for the WEI does

not yet exist, the agent creates a new weak event in-

stance and puts it into the agent’s EQ event queue.

Otherwise, the achievement goal is already processed

or ready to be processed so the agent ignores it. Thus,

if a new WEI is created, then it consists of the achieve-

ment goal atom, an intention identiﬁer, and a context

that is computed from the context of the original plan

truncated to the variables of the achievement goal. In

this case, the achievement goal is not removed from

the plan and remains in the body of the plan until the

agent achieves it.

CLEARINT2

i = hevt,ix,ctxi[hte

,!g(t

);h

,ctx

i ‡ h+!g(t

),null, ctx

i ‡ P| ∈ IS

ctx

= g(t

),ctx

∼ g(t

),ctx

hPB,EQ,BB,AS,ISi =⇒

ACT

hPB,EQ,BB,AS,(IS − {i}) ∪ {hevt,ix,ctxi[hte

,ctx

i ‡ P|}i

CLEARFAIL2

i = hevt,ix,ctxi[hte

,!g(t

);h

,ctx

i ‡ hte

, f ail,ctx

i ‡ P| ∈ IS

hPB,EQ,BB,AS,ISi =⇒

ACT

hPB,EQ,BB,AS,(IS − {i}) ∪ {hevt,ix,ctxi[hte

,!g(t

);h

,ctx

i ‡ P|}i

TESTG

ctx

= ctx u ρU(g(t), BB) 6=

hEQ,BB,AS,(ix :?g(t);h, ctx)i → hEQ,BB,AS,(ix : h,ctx

TESTFL

ctx u ρU(g(t),BB) =

hEQ,BB,AS,(ix :?g(t);h, ctx)i → hEQ,BB,AS,(ix : f ail, ctx)i

ACHIEVEG

ctx

= ctx ≺ q(t)

h!q(t),ix,ctx

i[P| /∈ IS

h+!q(t),ix,ctx

i /∈ EQ

hEQ,BB,AS,(ix :!q(t);h, ctx)i →

hEQ ∪{h!q(t),ix, ctx

i},BB,AS,(ix :!q(t);h, ctx)i

ICAART 2023 - 15th International Conference on Agents and Artiﬁcial Intelligence

178

ADDBB

σ ∈ (ctx ≺ c(t))

hEQ,BB,AS,(ix : +c(t);h,ctx)i → hEQ ∪ {h+c(t)σ,ix,ctx

},BB ∪ {c(t)σ}, AS, (ix : h,ctx u {σ})i

DELBB

σ ∈ (ctx ≺ c(t))

hEQ,BB,AS,(ix : −c(t);h,ctx)i → hEQ ∪ {h−c(t)σ,ix,ctx

},BB \ {c(t)σ}, AS,(ix : h,ctx u {σ})i

EXTACT

σ ∈ (ctx ≺ c(t))

hEQ,BB,AS,(ix : c(t);h,ctx)i → hEQ, BB, AS ∪ {c(t)σ},(ix : h, ctx u {σ})i

The previous rules changed the context using re-

strictions and other functions and operations intro-

duced in section 3. External actions, as well as both

types of internal actions, must be precisely speciﬁed.

In other words, the agent must know exactly what to

do. For this reason, the action atom must be ground

and the agent must decide which concrete substitution

or substitutions to use from the context of the plan.

This does not mean that only one set of substitutions

can remain in the context. Note that there can be more

than one set of substitutions that map free variables of

action atoms to the same terms. Again, the shorting

function is used use here, which takes a context with

an action atom and maps them to one particular set

of substitutions of that atom. If we use these substi-

tutions to restrict the context of the original plan, we

get a new context that suits the executed action.

The following three rules ADDBB, DELBB and

EXTACT respond to the execution of an action during

the execution of a plan. It may be the addition or re-

moval of a belief from the belief base. Rules ADDBB

and DELBB are used in these situations.

Similarly, we can deﬁne the DELBB rule. In both

rules, the most suitable substitution is selected ﬁrst

and the action is removed from the body of the cur-

rently executing plan. A new WEI is then put into the

agent’s event queue EQ. The result of the restriction

of the context of the plan and {σ} is used as the new

context for the top-level plan. The substitution σ is

applied to the belief c(t) and the result is inserted or

removed from the belief base BB.

The last rule is used when an external action is

performed.

Also in this rule, the substitution σ is chosen and

is used to compute the new context. The chosen sub-

stitution is also applied to the external event c(t) and

the result is inserted into the set of action AS.

6 CONCLUSIONS

We consider the transition system introduced in this

paper to be a basic formal speciﬁcation of the inter-

pretation of AgentSpeak(L) language using late bind-

ings. Such an interpretation introduces more ﬂexibil-

ity into agent decision-making by preserving options

until a speciﬁc decision needs to be made to perform

an action, compared to the original approaches. This

agent does not give up options for its future actions

prematurely and can correct its behaviour during the

execution of each plan according to the current situa-

tion or its current beliefs about the state of the system.

Currently, such an interpretation is implemented in

the system we program in the PROLOG language. In

this system, it can also be practically veriﬁed that for

some agent programs in that language, the agent can

deal with situations that fail in systems with classi-

cal interpretation. However, there are still a few open

areas, for example, the intention selection function is

not deﬁned. Its implementation can be done in sev-

eral ways, so it will be necessary to design several

solutions and compare them with each other on a pre-

prepared set of examples using well-deﬁned metrics.

This will be the direction of our future work.

ACKNOWLEDGEMENTS

This work has been supported by the internal BUT

project FIT-S-20-6427.

REFERENCES

Bordini, R. H., H

ubner, J. F., and Wooldridge, M. (2007).

Programming multi-agent systems in AgentSpeak us-

ing Jason, volume 8. John Wiley & Sons.

Caillou, P., Gaudou, B., Grignard, A., Truong, C. Q., and

Taillandier, P. (2017). A simple-to-use bdi architecture

for agent-based modeling and simulation. In Advances

in Social Simulation 2015, pages 15–28. Springer.

Operational Semantic of an AgentSpeak(L) Interpreter Using Late Bindings

179

d’Inverno, M., Kinny, D., Luck, M., and Wooldridge, M.

(1997). A formal speciﬁcation of dmars. In Inter-

national Workshop on Agent Theories, Architectures,

and Languages, pages 155–176. Springer.

Harland, J., Morley, D. N., Thangarajah, J., and Yorke-

Smith, N. (2014). An operational semantics for the

goal life-cycle in bdi agents. Autonomous agents and

multi-agent systems, 28(4):682–719.

Moreira,

A. F. and Bordini, R. H. (2002). An operational

semantics for a bdi agent-oriented programming lan-

guage. In Proceedings of the workshop on logics

for agent-based systems (LABS-02), held in conjunc-

tion with the Eighth International Conference on Prin-

ciples of Knowledge Representation and Reasoning

(KR2002), April, volume 22, pages 45–59.

Moreira,

A. F., Vieira, R., and Bordini, R. H. (2003).

Extending the operational semantics of a bdi agent-

oriented programming language for introducing

speech-act based communication. In International

Workshop on Declarative Agent Languages and Tech-

nologies, pages 135–154. Springer.

Nunes, I. and Luck, M. (2014). Softgoal-based plan selec-

tion in model-driven bdi agents. In Proceedings of the

2014 international conference on Autonomous agents

and multi-agent systems, pages 749–756.

Plotkin, G. D. (1981). A structural approach to operational

semantics. Aarhus university.

Rao, A. S. (1996). Agentspeak (l): Bdi agents speak

out in a logical computable language. In European

workshop on modelling autonomous agents in a multi-

agent world, pages 42–55. Springer.

Sardina, S. and Padgham, L. (2011). A bdi agent pro-

gramming language with failure handling, declarative

goals, and planning. Autonomous Agents and Multi-

Agent Systems, 23(1):18–70.

Waters, M., Nebel, B., Padgham, L., and Sardina, S. (2018).

Plan relaxation via action debinding and deordering.

In Twenty-Eighth International Conference on Auto-

mated Planning and Scheduling.

Waters, M., Padgham, L., and Sardina, S. (2015). Improv-

ing domain-independent intention selection in bdi sys-

tems. Autonomous Agents and Multi-Agent Systems,

29(4):683–717.

Yao, Y. and Logan, B. (2016). Action-level intention se-

lection for bdi agents. In Proceedings of the 2016

International Conference on Autonomous Agents &

Multiagent Systems, AAMAS ’16, page 1227–1236.

International Foundation for Autonomous Agents and

Multiagent Systems.

Zboril Jr, F., Vidensky, F., Koci, R., and Zboril, F. V. (2022).

Late bindings in agentspeak (l). In ICAART (3), pages

715–724.

ICAART 2023 - 15th International Conference on Agents and Artiﬁcial Intelligence

180