AgentSpeak(L)

Technique 1: the agent’s state

Problem it solves: knowing what’s inside an AgentSpeak agent.

There are no separate desires: goals appear inside plans and as events.

Technique 2: beliefs, goals and events

Problem it solves: the vocabulary every trace uses.

• Goals: ?b tests whether \(b\) follows from beliefs (and binds variables). !b asks to bring about a world where \(b\) is believed; it posts an internal event that triggers a plan.
• Events: +p / -p come from perception or messages: external. +!p comes from a running intention \(i\) meeting !p: internal, stored as \((+!p, i)\), “achieve \(p\) as part of intention \(i\)”.
• Intention: a stack \([r_k, \dots, r_1]\). \(r_1\) started it; the top \(r_k\) is running now; each plan was pushed to achieve a subgoal of the one below.

Technique 3: writing plans

Problem it solves: the program itself.

triggering_event : context <- body.
     e           : b1 & ... & bm <- h1; ...; hk.

• the trigger says which events the plan is relevant to;
• the context is belief conditions that must hold for it to be applicable;
• the body is actions, ! goals and ? goals, in order.

+!quench_thirst : have_glass <-
        !have_soft_drink;
        fill_glass;
        drink.

+!have_soft_drink : soft_drink_in_fridge <-
        open_fridge;
        get_soft_drink.

+rock_seen(R) : not battery(low) <-
        ?location(R, L);
        !move_to(L);
        pick_up(R).

Technique 4: the applicable unifier

Problem it solves: decides whether a plan can handle an event, and fills in its variables.

A plan e' : b1 & ... & bm <- body is applicable to event \(e\) if

1. the trigger unifies with the event: \(e\theta = e'\theta\), and
2. the context follows from current beliefs under some further \(\sigma\).

\(\theta\sigma\) is the applicable unifier. It’s Prolog: match the head, then solve the body against the beliefs.

Technique 5: selection functions

Problem it solves: when several things could happen next, who decides?

• \(S_E\) picks the event to handle;
• \(S_O\) picks the option: which applicable plan;
• \(S_I\) picks which intention to run a step of.

These are not written in AgentSpeak. Usual defaults (Jason’s): \(S_E\) oldest event first, \(S_O\) first applicable plan in the order written, \(S_I\) round-robin. So the order of your plans matters, as in Prolog.

Discussion (slide 23): is “precise syntax, unprogrammable semantics” progress? The most important choice, which plan to run, sits outside the language. A fair position: the opacity has been narrowed and relocated, not removed. Everything else now has a precise meaning, and the three functions can be fixed and documented.

Technique 6: tracing the execution cycle

Problem it solves: the long exam question: list the actions and the intention stack step by step.

Each cycle:

1. perceive, update \(B\); each change becomes a +b or -b event;
2. \(e := S_E(E)\);
3. pick an applicable plan with \(S_O\);
4. if \(e\) is internal (from intention \(i\)), push the plan on top of \(i\); otherwise start a new intention;
5. \(i := S_I(I)\); look at the first step of \(i\)’s top plan: an action runs; !b posts \((+!b, i)\) and \(i\) waits; ?b binds variables if it follows from beliefs, otherwise “???”;
6. if the top plan’s body is empty, pop it; if the intention is empty, remove it.

Jason (slide 52) is AgentSpeak’s practical implementation: it adds strong negation, plan-failure handling, speech-act communication, organisations (Moise) and distribution (JADE). You don’t need its details for the exam.

What to read in the book

Practice prompt

I'm studying CS5940 Intelligent Agents (Rao's AgentSpeak(L) and the Jason interpreter; Wooldridge 4.4 on PRS). I want practice on AGENTSPEAK(L):
- the agent's state (beliefs, events, intentions as stacks, plan library) and why there are no separate desires
- test goals ?b vs achievement goals !b; external events (+p, -p) vs internal events (+!p)
- reading and writing plans "trigger : context <- body."
- relevant vs applicable plans, and computing theta, sigma and the instantiated body for a given event and belief base (including negation as failure in contexts)
- the selection functions S_E, S_O, S_I, their usual defaults, and why plan order matters
- tracing the execution cycle step by step: which plan is chosen, how the intention stack grows and shrinks, which actions run
- what happens when a test goal or subgoal fails

Please:
1. Use plain, everyday language and explain any notation in one short sentence.
2. Give me ONE question at a time, easy first, then harder; give the plan library and beliefs in full.
3. Wait for my answer, then mark it and show the full trace with the intention stack at each step.
4. If I get it wrong, explain the mistake and give me a similar question.
5. Every 5 questions, summarise my strengths and what to practise.