DA A AD A (From Agents to Artifacts Back and Forth) Towards a Cognitive use of Artifacts in MAS

Transcription

1 EMSE - séminaires G2I DA A AD A () Towards a Cognitive use of Artifacts in MAS Michele Piunti alice group at DEIS, Università di Bologna, Cesena Istituto Scienze e Tecnologie della Cognizione ISTC-CNR, Roma michele.piunti@unibo.it with: - Alessandro Ricci, Researcher at DEIS - Mirko Viroli, Andrea Omicini 1

2 OUTLINE Environment Programming in (Programming) MAS - the road to artifacts and CARTAGO A&A model and CARTAGO platform - programming model and technology - integration with existing cognitive agent platforms Agents and Artifacts in the Loop of Cognitive Interactions - Doxastic Use - Operational Use - Goal-Directed Use 2

3 PART I ENVIRONMENT PROGRAMMING IN (PROGRAMMING) MAS - The ROAD to CARTAGO - 3

4 THE ROLE OF ENVIRONMENT IN MAS Traditional (D)AI / agent / MAS view - the target of agent actions and source of agents perception - something out of MAS design / engineering percepts AGENT(s) actions New perspective in recent works - environment as first-class aspect in engineering MAS ENVIRONMENT mediating interaction among agents encapsulating functionalities and services for enabling/ managing such interactions - coordination, organisation, security,... 4

5 FROM MAS TO MAS PROGRAMMING Specific perspective on MAS programming - agents (and MAS) as a paradigm to design and program software systems computer programming perspective - computational models, languages,... software engineering perspective - architectures, methodologies, specification, verification,... Underlying objective in the long term - using agent-orientation as general-purpose post-oo paradigm for computer programming concurrent / multi-core / distributed programming in particular 5

6 THE ROLE OF SW ENVIRONMENT IN MAS PROGRAMMING (SO FAR) MAS MAS ENVIRONMENT actions SIMULATED WORLD mimicking REAL WORLD (PHYSICAL OR COMPUTATIONAL) OR INTERFACE OR EXTERNAL WORLD (PHYSICAL OR COMPUTATIONAL) AGENTS percepts WRAPPER TO EXISTING TECHNOLOGY Example: JAVA PLATFORM 6

7 ENVIRONMENT MODELS IN MAS Environment as monolithic / centralised block - defining agent (external) actions typically a static list of actions, shared by all the agents - generator of percepts establishing which percepts for which agents Typically enough for toy problems, but... No specific (programming) model for defining structure and behaviour - including concurrency management - relying on lower-level language features and mechanisms (i.e. Java) No support for interoperability across platforms 7

8 AGENTS AND PERCEPTION Perception mechanisms in agents are often built upon the environment model - inheriting its weakness... Models are often domain dependent Based on the mechanisms inherited from OO (Java) Great attention for message exchange and ACL - Sophisticated infrastructure for message passing, but... - Protocols, Ontologies, Computational load on Agents In general, for other kinds of percepts: - Information flow is shaped based on the format provided by the adopted environment - No clear distinction, at a reasoning level, between practical and perceptive activities 8

9 ENVIRONMENT IN MAS PROGRAMMING? MAS actions PERCEPTION IN AUTONOMOUS AGENTS?? percepts? AGENTS 9

10 JASON EXAMPLE - GOLD-MINER DEMO - public class MiningPlanet extends jason.environment.environment {... public void init(string[] args) {... public boolean executeaction(string ag, Structure action) { boolean result = false; int agid = getagidbasedonname(ag); if (action.equals(up)) { result = model.move(move.up, agid); else if (action.equals(down)) { result = model.move(move.down, agid); else if (action.equals(right)) {... return result; private void updateagpercept(string agname, int ag) {clearpercepts(agname); // its location Location l = model.getagpos(ag); addpercept(agname, Literal.parseLiteral("pos(" + l.x + "," + l.y + ")")); if (model.iscarryinggold(ag)) { addpercept(agname, Literal.parseLiteral("carrying_gold")); // what's around updateagpercept(agname, l.x - 1, l.y - 1); updateagpercept(agname, l.x - 1, l.y);... 10

11 ENRICHING THE VIEW: WORK ENVIRONMENTS Perspective: designing worlds in agent systems for agents use - designing good and effective place for agents to live and work in environment as the context of agent activities inside the MAS - beyond simulated worlds Work environment notion - that part of the MAS that is designed and programmed so as to ease agent activities and work first-class entity of the agent world cooperation, coordination, organisation, security... facilities and functionalities as pivotal element of MAS design and programming - abstractions? computational models? languages? platforms? methodologies? 11

12 BACKGROUND LITERATURE In human sciences - Activity Theory, Distributed Cognition importance of the environment, mediation, interaction for human activity development - Active Externalism / extended mind (Clark, Chalmer) environment s obejcts role in aiding cognitive processes CSCW and HCI - importance of artifacts and tools for coordination and collaboration in human work Distributed Artificial Intelligence - Agre & Horswil work ("Lifeworld"...) - Kirsch ("The Intelligent Use of Space"...)

13 A HUMAN WORK ENVIRONMENT (~BAKERY) 13

14 ARTIFACTS ARE IN THE AGENT MAINSTREAM...not really, actually... an artifact agent agent artifacts agent 14

15 AGENTS & ARTIFACTS (A&A) MODEL: BASIC IDEA IN A PICTURE CLOCK artifact WHITEBOARD artifact BAKERY workspace agents can join dynamically the workspace ARCHIVE artifact COM. CHANNEL artifact RESOURCE artifact TASK SCHEDULER artifact 15

16 DESIDERATA FOR A WORK. ENV. PROGRAMMING MODEL (1/2) Abstraction - keeping the agent abstraction level concepts like Action, Perception, Observation i.e., no agents sharing and calling OO objects - effective programming models for controllable and observable computational entities Orthogonality - wrt agent models, architectures, platforms - support for heterogeneous systems MAS AGENTS actions percepts? 16

17 DESIDERATA FOR A WORK ENV. PROGRAMMING MODEL (2/2) (Dynamic) extendibility - dynamic construction, replacement, extension of environment parts - support for open systems MAS actions Modularity - away from the monolithic and centralised view? Reusability - reuse of environment parts in different application contexts / domains AGENTS percepts 17

18 PART II A&A MODEL and CARTAGO PROGRAMMING MODEL & PLATFORM 18

19 A&A BASIC CONCEPTS Agents - autonomous, goal-oriented, social, pro-active entities - create and co-use artifacts for supporting their activities besides direct communication Artifacts - non-autonomous, authomatic, function-oriented entities controllable and observable - modelling the tools and resources used by agents designed by MAS programmers Workspaces - logically grouping agents & artifacts - defining the topology of the computational environment 19

20 WORK ENVIRONMENT IN A&A MAS actions? AGENTS percepts 20

21 WORK ENVIRONMENT IN A&A Artifacts as building bricks to structure the (work) environment Workspaces as topological structure of the w.e. MAS wsp Abstraction - encapsulation - information hiding Modularization - extendibility - reuse AGENTS wsp 21

22 WORK ENVIRONMENT IN A&A Artifacts as Interfaces and Facades to external world(s) MAS printer EXTERNAL WORLD (PHYSICAL OR COMPUTATIONAL) wsp gui AGENTS wsp HUMAN USERS 22

23 WORK ENVIRONMENT IN A&A MAS blackboard Interaction from A to A based on not ambigous notions of: wsp Action, Perception, Observation AGENTS wsp 23

24 WORK ENVIRONMENT IN A&A Agents Externalising Activities and Resources MAS personal agenda (ext. memory) wsp GUI AGENTS wsp 24

25 ARTIFACT COMPUTATIONAL MODEL Artifacts as controllable and observable devices - operation execution as a controllable process possibly long-term, articulated - two observable levels observable properties, signalled events - transparent management of concurrency issues synchronisation, mutual-exclusion, etc Composability through link interfaces - also across workspaces Cognitive use of artifacts through the manual - function description, operating instructions - work in progress 25

26 ARTIFACT COMPUTATIONAL MODEL - COFFEE MACHINE METAPHOR - OBSERVABLE EVENTS GENERATION <EvName,Params> ObsPropName Value OBSERVABLE PROPERTIES ObsPropName Value USAGE INTERFACE OpControlName(Params) OpControlName(Params)... OPERATION X OPERATION Y ARTIFACT MANUAL LINK INTERFACE 26

27 INTERACTION MODEL: USE ObsPropName ObsPropName Value Value use myopcontrol(x) myopcontrol(x) AGENT use action - acting on op. controls to trigger op execution - synchronisation point with artifact time/state 27

28 INTERACTION MODEL: USE ObsPropName ObsPropName... Value Value... myopcontrol(x) AGENT OPERATION EXECUTION artifact operation execution - asynchronous and not coupled wrt agent executions - possibly a process, structured in multiple atomic steps 28

29 INTERACTION MODEL: USE EVENTS ObsPropName Value OBS PROPERTIES CHANGE myopcontrol(x) AGENT observable effects - observable events & changes in obs property - perceived by agents either as (external) events 29

30 INTERACTION MODEL: OBSERVATION PName Value observe property (+PName,?Value) myopcontrol(x) AGENT observeproperty (intentional) action - value of an obs. property as action feedback - weak interaction 30

31 INTERACTION MODEL: OBSERVATION ObsPropName(Value). ObsPropName(Value).... ObsPropName Value Belief base (or alike) focus ObsPropName Value myopcontrol(x) AGENT focus / stopfocus action - start / stop a continuous observation of an artifact possibly specifying filters - observable properties mapped into percepts (or Belief base) 31

32 INTERACTION MODEL: OBSERVATION ObsPropName(Value). ObsPropName(Value).... Belief base (or alike) ObsPropName ObsPropName Value Value myopcontrol(x) USE AGENT continuous observation - observable events (=> agent events) - observable properties ( => belief base update) 32

33 EXAMPLES OF ARTIFACTS Common tools and resources in MAS blackboards, tuple centres, synchronisers,... maps, calendars, shared agenda,... data-base, shared knowledge base,... hardware res. wrappers GUI artifacts... - principled way to design / program / use them inside MAS Specific & articulated purposes - example: logic-based spreadsheet artifact 33

34 LOGIC-BASED SPREADSHEET ARTIFACT SKETCH A1 p(1). p(2). B1 q(1). q(3). A2 r(x):-p(x),q(x). B2 result of?- q(5). A3 result of?- r(1). B setcelltheory(cellid: String, t: Theory) setcellcontext(cellid: String, context: List<CellId> context) setcellgoal(cellid: String, g: GoalFormula) 34

35 CARTAGO CARTAGO platform / infrastructure - runtime environment for executing (possibly distributed) artifact-based environments - Java-based programming model for defining artifacts - set of basic AGENT-API to work wihin artifact-based environment integration with agent programming platforms Distributed and open MAS - workspaces distributed on Internet nodes agents can join and work in multiple workspace at a time - Role-Based Access Control (RBAC) security model Open-source technology - available at 35

36 ...AND FRIENDS Integration with existing agent platforms - cognitive agent platforms in particular ongoing cooperation with Jomi, Rafael, Alexander, Lars, Mehdi - available bridges: Jason, Jadex, simpa ongoing: 2APL, Jade - agent body notion for technically realising the integration effectors and sensors to act upon and sense artifacts controlled by an agent mind executed on some agent platform Outcome - developing open and heterogenous MAS - different perspective on interoperability sharing and working in a common work environment common data-model based on Object-Oriented or XML-based data structures 36

37 CARTAGO ARCHITECTURE Application Agents Artifact-based working environments MAS Application shared workflow engine task scheduler workspaces shared shared kb KB blackboard map Application Specific Logic Execution Platform Agent Framworks / Middlewares JASON JASON 3APL JADEX JADE... agent bodies workspaces artifacts CARTAGO MAS Middleware Layer Any OS JVM JVM OS 37

38 DEFINING ARTIFACTS IN CARTAGO Single class extending alice.cartago.artifact Specifying the operations - methods name+params -> usage interface control no return value - structured linear composition of atomic operation steps composed dynamically - init operation automatically executed when the artifact is created Specifying artifact state - instance fields of the class 38

39 SIMPLE EXAMPLE #1 inc USAGE INTERFACE: inc: [ op_exec_completed ] public class Count extends Artifact { int void init(){ count = void inc(){ count++; 39

40 OBSERVABLE EVENTS generated, within artifact operations, by the signal primitive AGENT EVENTS ObsPropName Value myopcontrol(x) OBS PROPERTIES CHANGE represented as labelled tuples - event_name(arg0,arg1,...) Automatically made observable to... - the agent who executed the operation - all the agents observing the artifact 40

41 SIMPLE EXAMPLE #2 inc USAGE INTERFACE: inc: [ new_count_value, op_exec_completed ] public class Count extends Artifact { int void init(){ count = void inc(){ count++; signal("new_count_value", count); 41

42 OBSERVABLE PROPERTIES declared by defineobsproperty primitive - characterized by a property name and a property value ObsPropName(Value). ObsPropName(Value).... Belief base (or alike) AGENT ObsPropName Value ObsPropName Value myopcontrol(x) USE internal primitives to read / update property value - updateobsproperty - getobsproperty Automatically made observable to all the agents observing the artifact 42

43 SIMPLE EXAMPLE #3 count 5 inc OBSERVABLE PROPERTIES: count: int USAGE INTERFACE: inc: [ op_exec_completed ] public class Count extends Artifact void init(){ defineobsproperty("count", void inc(){ int count = getobsproperty("count"); updateobsproperty("count", count + 1); 43

44 MORE ON ARTIFACTS Structured operations - specifying operations composed by chains of atomic operation steps - to support the concurrent execution of multiple operations on the same artifact by interleaving steps Linkability - dynamically composing / linking multiple artifacts together Artifact manual - machine-readable description of artifact functionality and operating instructions 44

45 STRUCTURED OPERATIONS Complex operations as chains of guarded atomic operation step execution methods Guards UI CONTROL TO TRIGGER OP EXECUTION G G once enabled, the operation step is executed as soon as the OP STEP OP STEP OP STEP USAGE INTERFACE GUARDS - boolean expression over the artifact state guard is evaluated to true > Multiple structured operations can be executed concurrently on the same STRUCTURED artifact OPERATIONby interleaving... their steps - with only one step executed at a time 45

46 EXAMPLE public class MyArtifact extends Artifact { Data valuea, void requestvalue(){ valuea = valueb = null; requestvalue notifyvalues nextstep("notifyvalues"); void notifyvalues(){ signal( values,valuea,valueb); insertvaluea boolean valuesavailable(){ return valuea!=null && valueb!=null; requestvalue structured operation void insertvalueb insertvaluea(data v){ valuea = void insertvalueb(data v){ valueb = v; G: valuesavailable insertvaluea atomic op insertvalueb atomic op MyArtifact ARTIFACT 46

47 INTEGRATION TECHNOLOGIES Agents and Artifact (A&A) Interactions are defined at a language level, through he definition of (special purpose) internal actions Actions realize step by step the workflow of activities required to achieve a given task CARTAGO has integration technologies to enable of several agent platforms to play in artifact based environments Heterogeneous & remote agents c4jason, c4jadex c4simpa, etc. 47

48 OPEN WORKSPACES & DISTRIBUTION Agents can dynamically join and quit workspaces - in Jason CARTAGO is enabled by: alice.c4jason.cenv environment class RBAC model for ruling agent access & use of artifacts - security-registry artifact to keep track of roles and role policies making roles & policies observable and modifiable by agents themselves Distribution - agents can join and work concurrently in multiple workspaces at a time - workspaces can belong to different CARTAGO nodes 48

49 AGENT ABSTRACT API Extending agents repertoire with a basic set of actions enabling playing within artifact-based environment workspace management joinwsp(name,?wspid,+node,+role,+cred) quitwsp(wid) artifact use use(aid,opcntrname(params),+sensor,+timeout,+filter) sense(sensor,?perception,+filter,+timeout) grab([aid]) release([aid]) artifact observation artifact instantiation, discovery, management observeproperty(aid,pname,?pvalue) focus(aid,+sensor,+filter) stopfocus(aid) makeartifact(name,template,+artifactconfig,?aid) lookupartifact(name,?aid) disposeartifact(aid) 49

50 RAW AGENT API joinwsp use sense focus stopfocus grab release + basic set of default artifacts available in each workspace - factory - registry - security-registry - console implementing non primitive actions: makeartifact => use factory lookupartifact => use registry... 50

51 CARTAGO API TASTE EX1: SIMPLE USE A shared counter MAS mas0a { inc USAGE INTERFACE: inc: [ new_count_value, op_exec_completed ] environment: alice.c4jason.cenvstandalone agents: user0a agentarchclass alice.c4jason.cagentarch; package test; import alice.cartago.*; public class Counter0 extends Artifact { int void init(){ count = void inc(){ count++; signal("new_count_value",count); // user0a!create_and_use. +!create_and_use : true <- cartago.makeartifact("mycount","test.counter0",c); // first use cartago.use(c,inc); // second use cartago.use(c,inc,s0); cartago.sense(s0,new_count_value(v)); // log the value cartago.use(console,println("[user] value ",V)). 51

52 CARTAGO API TASTE EX2: SIMPLE USE A shared counter MAS mas0b { inc USAGE INTERFACE: inc: [ new_count_value, op_exec_completed ] environment: alice.c4jason.cenvstandalone agents: user0b agentarchclass alice.c4jason.cagentarch; package test; import alice.cartago.*; public class Counter0 extends Artifact { int void init(){ count = 0; // user0b!create_and_use. +!create_and_use : true <- cartago.makeartifact("mycount","test.counter0",c); // first use cartago.use(c,inc); // second use void inc(){ count++; signal("new_count_value",count); +artifact_event(c,new_count_value(v)) : true <- cartago.use(console,println("[user] value ",V)). 52

53 CARTAGO API TASTE EX3: USE & OBSERVATION Counter with obs prop count 5 inc OBSERVABLE PROPERTIES: count: int USAGE INTERFACE: inc: [ op_exec_completed ] MAS mas1 { environment: alice.c4jason.cenvstandalone agents: observer agentarchclass alice.c4jason.cagentarch; user agentarchclass alice.c4jason.cagentarch #2; // user!use_count. package test; public class Counter1 extends Artifact void init(){ defineobsproperty("count",0); // void inc(){ int count = getobsproperty("count").intvalue(); updateobsproperty("count",count+1); +!observe : true <- cartago.makeartifact("my_counter","test.counter1", Count); cartago.focus(count). +count(v) : true <- cartago.use(console,println("current count observed: ",V)). +!use_count : true <-?counter_to_use(counter) ; +cycle(0) ;!use_count(counter). +?counter_to_use(counter) : true <- cartago.lookupartifact("my_counter",counter). -?counter_to_use(counter) : true <-.wait(100);?counter_to_use(counter). +!use_count(c) : cycle(n) & N < 10 <- -cycle(n); cartago.use(c,inc,mysensor0); cartago.sense(mysensor0,"operation_completed");!have_a_rest ; +cycle(n+1) ;!use_count(c). +!use_count(c) : cycle(10). +!have_a_rest : true <-.wait(10). 53

54 CARTAGO API TASTE EX4: USING OP CONTROLS WITH GUARDS bounded-buffer artifact for open producers-consumers scenarios n_items 0 max_items 100 put get public class BBuffer extends Artifact { private LinkedList<Item> void init(int nmax){ items = new LinkedList<Item>(); defineobsproperty("maxnitems",nmax); defineobsproperty("nitems",0); OBSERVABLE PROPERTIES: n_items: int+ max_items: int Invariants: n_items <= max_items USAGE INTERFACE: put(item:item) / (n_items < max_items): [ op_exec_completed ] get / (n_items >= 0) : [ new_item(item:item), op_exec_completed void put(item obj){ items.add(obj); boolean buffernotfull(item obj){ int maxitems = getobsproperty("maxnitems").intvalue(); return items.size() < void get(){ Item item = items.removefirst(); updateobsproperty("nitems",items.size()-1); boolean itemavailable(){ return items.size() > 0; 54

55 CARTAGO API TASTE PRODUCERS & CONSUMERS IN JASON PRODUCERS!produce. +!produce: true <-!setuptools(buffer);!produceitems. +!produceitems : true <-?nextitemtoproduce(item); cartago.use(mybuffer,put(item),5000);!produceitems. +?nextitemtoproduce(item) : true <-... +!setuptools(buffer) : true <- cartago.makeartifact("mybuffer", "test.bbuffer",[10],buffer). -!setuptools(buffer) : true <- cartago.lookupartifact("mybuffer",buffer). CONSUMERS!consume. +!consume: true <-?buffertouse(buffer);.print("going to use ",Buffer);!consumeItems. +!consumeitems : true <- cartago.use(mybuffer,get,s0,5000); cartago.sense(s0,new_item(item),5000);!consumeitem(item);!consumeitems. +!consumeitem(item) : true <-... +?buffertouse(bufferid) : true <- cartago.lookupartifact("mybuffer",bufferid). -?buffertouse(bufferid) : true <-.wait(50);?buffertouse(bufferid). 55

56 CARTAGO API TASTE EX5: ARTIFACT WITH STRUCTURED OPERATIONS simple synchronization artifact (~barrier) n_participants 13 all_ready false class SimpleSynchronizer extends Artifact { int void init(int nparticipants){ defineobsproperty("all_ready",false); defineobsproperty("n_participants",0); nready = 0; this.nparticipants = nparticipants; ready OBSERVABLE PROPERTIES: n_participants: N > 0 all_ready: {true,false USAGE INTERFACE: ready / true : [ accepted(n), op_exec_completed void ready(){ nready++; signal( accepted,nready); void setallready(){ boolean allready(){ return nready == getobsproperty("n_participants").intvalue(); 56

57 CARTAGO API TASTE SYNCH USER (ACTIVE/REACTIVE) SYNCH USER - WITH SENSOR!work. +!work: true <-... // locate the synch tool cartago.lookupartifact( mysynch,synch); // ready for synch cartago.use(synch,ready,sid); // waiting all synchs cartago.sense(sid,op_exec_completed(ready); // all ready, go on.... SYNCH USER - REACTIVE!work. +!work: true <-... // locate the synch tool cartago.lookupartifact( mysynch,synch); // ready for synch cartago.use(synch,ready). // observe it. cartago.focus(synch). // react to all_ready(true) percept +artifact_event(mysynch,all_ready) : true <- // all ready, go on

58 PART III AGENTS AND ARTIFACTS IN THE LOOP OF COGNITIVE INTERACTIONS 58

59 Conceiving A&A Systems Artifacts provide serviceable operations, preprocessed information and coordination facilities conceived by the MAS designer for easing agents tasks What s for agent architectures and systems When Agents are reasoning? /w mental states (Beliefs, Goals, Intentions)? Fuctional Approach to A&A design From an agent viewpoint, artifacts embeds: - - Informationtional (Doxastic) Function Operational (Purposive) Function 59

60 A&A Ecosystems An ecosystem is a natural unit consisting of all plants, animals and micro-organisms (biotic factors) in an area functioning together with all of the non-living physical (abiotic) factors of the environment. [Christopherson, RW (1996)] Individual Knowledge Tools ECOSYSTEM Agent Artifact Information Agent If you are a MAS developper... Operations 1. Agents as intentional systems [Dennett] Artifact A&A ECOSYSTEM 2. Artifact are supposed to be (not only) external component (but also) funcional resources of the MAS 60

61 Purposive Function Operations are Artifacts intended purposes - Intented is in the mind of Artifact Designers before beeing in agents intentions From an agent viewpoint, Artifacts are nonautonomous but automatic devices providing functionalities Exploitable as self contained operations: - Improving repertoire of actions, as additional means to achieve Goals - Externalise and distribute part of agent activities 61

62 Purposive Function Goals can thus be achieved by the mean of operations which have been defined -by the artifact developer- within artifacts control interface. Agent s Goal is in Operation Outcomes: 62

63 Doxastic Function Artifacts include machine-readable Representations - Can maintain, make it observable, pre-process information From an agent viewpoint, Artifacts are informational units, exploitable in a situated way: - As external repositories, automatically collecting and providing strategic knowledge - Additional memory, even shared between agent groups - Observable cues in order to highlight relevant information in environments (situated cognition) 63

64 Artifact Observable properties can be exploited by agents to retrieve strategic information. The mechanism of observation is conceived as a weak interaction. Doxastic Function Strategic (Goal Supporting) knowledge is in artifacts readable properties: 64

65 PRODUCERS CONSUMERS Example: a variable number of Producer and Consumer Agents want to exchange generic Items Bounded resources: Time, Space, Memory.. PRODUCERS - Need for a strategy to sychronise, Item coordinate (conc. systems) Item CONSUMERS A Bounded Inventory Artifact is designed to function as a shared Inventory mediating the activities - Ruling and Enabling the exchange Inventory Size can be modified to change performance of the system 65

66 BOUNDED INVENTORY n_items 0 max_items 100 put get OBSERVABLE PROPERTIES: n_items: int+ max_items: int Invariants: n_items <= max_items USAGE INTERFACE: import alice.cartago.*; import java.util.*; public class BoundedInventory extends Artifact { private LinkedList<Item> void init(int nmax){ items = new LinkedList<Item>(); defineobsproperty("max_items",nmax); void put(item obj){ items.add(obj); void get(){ Item item = items.removefirst(); updateobsproperty("n_items",items.size()-1); boolean itemavailable(){ return items.size() > 0; put(item:item) / (n_items < max_items): [ obs_prop_updated, op_exec_completed ] get / (n_items >= 0) : [ obs_prop_updated, new_item(item:item), op_exec_completed boolean inventorynotfull(item obj){ int maxitems = getobsproperty("max_items").intvalue(); return items.size() < maxitems; 66

67 Purposive Function Both Producer and Consumer Goals are in Artifact outcomes, after the use All the computation required to synchronize interactions is externalised in the Bounded Inventory - It can possibly preprocess the items, e.g. tranlsate them to different ontologies 67

68 Doxastic Function Two bounded buffers are in place, each with a different load By focusing art. properties, Consumer can decide which is the most reliable one to use (Goal Supporting Beliefs) Update of Goal Supporting Beliefs is done authomatically - in reaction to a property change event 68

69 Cognitive Artifacts The notion is related to agents able to bring about artifact informational functions [Normann] To provide Relevant, Strategic Information to Single-Agent - Easy reasoning about goals: goal supporting beliefs - Simplifying agent choices and easing deliberation processes To distribute Information in Multi-Agent 1. Across Agents: organise and make available relevant information as permanent sideeffect of artifact use (modification of artifact state) 2. Across Platforms: mediated interactions 3. Across Time: hold strategic information persistent over agent presence 4. Across Space: no need for agents mutual presence within a location or heavy message exchange protocols 69

70 RoomsWorld Example GOAL: clean rooms Agents have bounded range of sight i.e., can locate trash items only entering the room To prevent wasting resources (time) agents need a good strategy to coordinate activities Each agent should deliberate the room to visit knowing and evaluating the activities performed by others The information about which room has already been cleaned is relevant for deciding the next curse of actions: GOAL-SUPPORTING BELIEFS 70

71 Introducing Cognitive Artifacts WATCH OBSERVABLE PROPERTIES tick_time long USAGE INTERFACE start() tick_time start long LOG OBSERVABLE PROPERTIES lastnote int USAGE INTERFACE putnote(object note) lastnote putnote int public class Watch extends Artifact long tick_time; private final long exp_length = void init(){ tick_time=0; public class Log extends Artifact { private LinkedList<String> notes; private String name; private location void start() { try { nextstep( "tick"); catch (Exception ex) int void init(string n, location l){ name=n; loc= l; notes = new void tick(){ if (tick_time<exp_length){ try { updateproperty( "tick_time", ++tick_time); // signal to synchronize dwelling agents signal( "grig_tick", tick_time); outsignal( "link", new Op("setSimTime", tick_time )); nextstep("tick"); catch (Exception ex){ else { signal( void putnote( Object ts ){ notes.addlast(ts.tostring()); lastnote = ((Integer)ts).intValue(); 71

72 DEMO 72

73 Easing Deliberation (Jason) Observable State <lastnote, VALUE> Agent _2 Operations Usage Interface Observable Events <DESCR,CONTENT> [... retrieve IDLog and IDWatch... ] cartago.observeproperty(idlog, lastnote(logt) ); cartago.observeproperty(idwatch, sim_time(wt));!decide(n, Wt, LogT). Observable State <lastnote, VALUE> Agent _1 Operations putnote(object ts) Observable Events <DESCR,CONTENT> Updating Goal-Supporting Beliefs... cartago.lookupartifact(log, LogID); cartago.use(logid, putnote(currenttime));... 73

74 Easing Deliberation (Jadex) Observable State <lastnote, VALUE> Agent _1 Operations putnote(object ts) Observable Events <DESCR,CONTENT> observeproperty() Observable State <sim_time,value> Operations Agent_2 Usage Interface Observable Events <DESCR,CONTENT> 74

75 Controlling Externalized Activities A pivotal aspect in A&A is for activities required for the control and the coordination of externalized processes Relations from cognitive agents to cognitive artifacts are bidirectional. External events coming from an artifact can be integrated at an architectural level by automatically promoting such events as signals requiring servicing - to be addressed within the reasoning processes. 75

76 Agents as Dual Systems Sometime is useful to divede goal processing (i.e. deliberation) from intention processing (i.e. means end reasoning) Goal Deliberation AGENT 2 Filtering 1 Plan Selection InternalEvent Observable State <NAME,VALUE> Operations Usage Interface Observable Events <DESCR,CONTENT> 1. Once encoded, the signal of a given interaction can bypass practical reasoning and trigger plans as reactions - Routinized activities and reactive behavior - No need for expansive deliberation processess 2. Particular events can be used for signalling someting wrong - Mismatch on filtering rules artifactevent - Reconsider Intention truough reasoning 76

77 An example: Artifact Based Contract-Net Buyer and Seller mediate their interactions in a Contract-Net Workspace 2 Artifacts, BuyerBoard and SellerBoard, are linked to propagate each other relevant information 77

78 Goal Directed Interaction Buyer adopt the Goal to buy a given book and initiate a call-for-proposal upon the BuyerBoard Goal directed agents can reason in terms of declarative Goals wich have a proper representation and lifecycle - Declarative Goals - Deliberation is Independent form intention selection - Twofold reasnonig processes for adopting Goals and selecting Plans 78

79 Contract Net Observable State <seller_reputation, VALUE> Operations MakeCfp Operations Register Buyer BuyBook GiveFeedb MakeProposal DeliverBook Seller PropResp Request ReceiveBook AcceptProp BuyerBoard SellerBoard 79

80 Contract Net Observable State <seller_reputation, VALUE> Operations MakeCfp Operations Register Buyer BuyBook GiveFeedb MakeProposal DeliverBook Seller PropResp Request ReceiveBook AcceptProp BuyerBoard SellerBoard 80

81 Contract Net Observable State <seller_reputation, VALUE> Operations MakeCfp Operations Register Buyer BuyBook GiveFeedb MakeProposal DeliverBook Seller PropResp Request ReceiveBook AcceptProp BuyerBoard SellerBoard 81

82 Contract Net Observable State <seller_reputation, VALUE> Operations MakeCfp Operations Register Buyer BuyBook GiveFeedb MakeProposal DeliverBook Seller PropResp Request ReceiveBook AcceptProp BuyerBoard SellerBoard 82

83 Concluding Remarks Artifacts can be cognitively used once their representational and operational contents are mapped into reasoning processes A&A interaction is approached at a programming level The problem is now how to make agents aware about artifacts which are not known at desing time Artifact Representional Contents (i.e. manuals, properties, interfaces) has to be gounded with agents epistemic (beliefs) and motivational (goals) states. 83

84 Two more Steps towards an Extended Mind [Clarks] Artifact discovery as a process of Epistemic Reasoning - Agents need to Read, learn, and match Artifact Representational contents Operational contents has to be included in Practical Reasoning (to achieve goals) - By changing the actions required for achieving a goal, artifact operations change means-end reasoning (planning) 84

85 CORE ASPECTS Defining an agent-understandable model & semantics for artifact manual - how to specify artifact functionalities - how to specify artifact operating instructions How to extend agent basic reasoning cycle including reasoning about artifacts - relating agent means ends reasoning and artifact functions - relating agent plans and artifact operating instructions and function description Reference literature - Artificial Intelligence, Planning, and Distributed AI - Semantic Web / Ontologies 85

86 FUTURE WORKS Objectives - enabling intelligent agents to dynamically discover and use (and possibly construct) artifacts according to their individual / social objectives - open systems systems with different kinds of aspects not defined a priory by MAS designers Toward fully autono(mic/mous) systems - exploring self-organizing systems based on intelligent agents self-chop+ca - configuring, healing, optimizing, protecting + constructing, adapting 86

87 ONGOING EVALUATION (APPLICATIONS) ORA4MAS (w/ Hubner, Boissier, Kitio, Ricci) - exploiting artifacts to build an organisational infrastructure CARTAGO-WS - basic set of artifacts for building SOA/WS applications interacting with web services implementing web services ARTIFACT LIBRARIES - setting up a set of reusable artifacts in MAS applications 87

88 REFERENCES Agens Faber: Toward A Theory of Artefacts for MAS Electronic Notes in Theoretical Computer Sciences, Elsevier Science B.V., 2006, 150, 'Give Agents their Artifacts': The A&A Approach for Engineering Working Environments. In 6th international Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS 2007). Honolulu, Hawai'i, USA, 2007 Ricci, A., Viroli, M., Omicini, A. The A&A Programming Model & Technology for Developing Agent Environments in MAS. ProMAS'07,Post-proceedings, Springer, 2007, 4908, Piunti, M., Ricci, A. Cognitive Artifacts for Intelligent Agents in MAS: Exploiting Relevant Information residing in Environments. Workshop on Knowledge Representation for Agents and Multi-Agent Systems (KRAMAS 2008), Sydney, 2008 Ricci, A., Piunti, M., Acay, L. D., Bordini, R.; Hubner, J., Dastani, M. Integrating Artifact-Based Environments with Heterogeneous Agent-Programming Platforms. In 6th international Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS'08). Estoril, 2008 Artifacts in the A&A meta-model for multi-agent systems. Journal of Autonomous Agents and Multi-Agent Systems, 2008, 17 (3) Piunti, M.; Ricci, A.; Braubach, L. & Pokahr, A. Goal-Directed Interactions in Artifact-Based MAS: Jadex Agents playing in CARTAGO Environments In IEEE/WIC/ACM International Conference on Web Intelligence and Intelligent Agent Technology. Sydney Piunti, M., Ricci, A. : Operational and Doxastic Use of Artifacts in MAS. In Proceedings of Sixth European Workshop on Multi-Agent Systems, to appear