peer-to-peer and agent-based computing

1. peer-to-peer and agent-based computing Agent communication (Cont’d)

2. Constructing Conversations • Conversations are patterns of message exchange: • Order of messages and their inter-relationships • E.g., you can only say “yes/no” if you are asked! • An engineer could give agents • Information on the semantics of messages in an ACL, and • The planning capability to ensure that effective interaction protocols arise spontaneously, but this is hard (impossible?) to do… • Do the things we say always mean the same? peer-to-peer and agent-based computing

3. Contextual Meaning John: “Where will you put the garbage for me to take out tomorrow morning?” Mary: “Behind the back door as usual.” John: “Where did you put the garbage?” Mary: “Behind the back door as usual.” • Are Mary’s commitments the same? peer-to-peer and agent-based computing

4. Protocol Specification • Conversation protocols: • Avoid computational overhead of agents building conversations “on-the-fly” • Provide contextual meaning of utterances • How do we specify conversations? • Generic/expressive (i.e., capture large classes of conversations) • Robust (i.e., allow for exceptions without breaking) • Let’s look at some proposals: • Finite automata • Agent UML • Dooley graphs • Electronic institutions peer-to-peer and agent-based computing

5. Protocol Specification (Cont’d) • Sample conversation 1: • Receive a number of offers • Choose one of them and accept it • Reject the others • Sample conversation 2: • There is an auctioneer w/ something to sell • There is at least one buyer • The auctioneer broadcasts a price to all buyers • A buyer may accept the current price • In this case, the conversation is over! • If no-one accepts the current price, then the auctioneer decreases it by 10% • In this case, the conversation carries on from step 3 peer-to-peer and agent-based computing

6. Finite Automata • A finite automaton (FA) is defined as: • a finite set of input symbols I • a finite set of states, S (a subset of which are final states), • An initial state q0 S • a “next state” function next : S × I  S • FAs specify communication protocols • A state in S denotes the state of the protocol, and • The symbols in I are messages. peer-to-peer and agent-based computing

7. Finite Automata: Example 1 2 1 A:ask_if(q) 3 4 B:tell(q) B:tell(q) I = {A:ask_if(q),B:tell(q),B:tell(q)}, • A and B are agent identifications • q is some proposition, that is, a fact about the world (e.g., “the fish is fresh”). S = {1,2,3,4}, where 3 and 4 are terminal states, q0=1 next(1,A:ask_if(q)) = 2 next(2,B:tell(q)) = 3 next(2,B:tell(q)) = 4 • Graphically: peer-to-peer and agent-based computing

8. Finite Automata: Example 2 A:accept(_) B:accept(_) 2 5 B:counter(_) 1 A:propose(_) 3 4 A:counter(_) B:reject(_) A:reject(_) peer-to-peer and agent-based computing

9. Finite Automata: Strengths • Simple, natural representation of relationships between utterances • Input symbols map naturally to speech acts. • Easy to detect (non-)conformance • A conversation conforms to the protocol if, and only if, it represents a path through the graph from the initial state to a final state • States through which dialogue progresses are clearly identified • Including initial and final states peer-to-peer and agent-based computing

10. Finite Automata: Limitations • Structure on input symbols to indicate who is speaking • E.g., B:tell(q) • Difficult to model conversations involving arbitrary numbers of agents • E.g., there should be 3-5 participants. • No representation of evolution of conversation • Only captures “legal” messages • No exception handling! • Scalability: Realistic conversations can be complex • “Spaghetti” diagrams peer-to-peer and agent-based computing

11. Agent UML • www.auml.org (various contributors) • AUML Protocol Diagrams (PDs) • Extension of UML sequence diagrams. • Specify partial order of messages of participants • Participants may be • A role (all agents taking on that role) or • A specific individual • PDs may represent multiple threads of interaction for each participant peer-to-peer and agent-based computing

12. Threads of Interaction query proxy inform inform • A participant may have various choices in the messages it sends. • The behaviour of the recipient depends on the incoming message(s). • PDs represent this different behaviour through multiple threads (AND, OR or XOR). peer-to-peer and agent-based computing

13. Agent UML: Example Contractor Manager cfp refuse not-understood deadline propose reject-proposal accept-proposal failure inform-done inform-ref peer-to-peer and agent-based computing

14. Agent UML: Strengths • Familiar representation • Availability of UML design tools • Transitions map cleanly to speech acts • Easy to detect (non-)conformance • Participants involved clearly identified • Captures the inherently multi-threaded nature of agent communication • Communication with allagents taking on some role may be represented peer-to-peer and agent-based computing

15. Agent UML: Limitations • No existential quantification over agent groups • “At least one agent must reply to this message” • No representation of evolution of conversation • Only captures “legal” messages • No exception handling! • Scalability: Realistic conversations can be complex • “Spaghetti” diagrams • Maintenance difficulties peer-to-peer and agent-based computing

16. Dooley Graphs • Proposed by R.A. Dooley (1976) • H.V.D. Parunak used for agent protocols (1996) • A Dooley Graph is: • A set of indexes E denoting acts (speech & non-speech acts), • A set of participants P (the nodes) • A set of triples A (the arcs) connecting the sender (participant pi sending utterance k) and the recipient (participant pj receiving k): A = {pi,pj,k:pi ,kS and k,pjR} • A relation M from S R to S R defining the vertices of the graph. These represent the links between arcs (acts) peer-to-peer and agent-based computing

17. Relations Between Acts • M captures various forms of relation between acts. • A question is intended to solicit a certain kind of response from the recipient. • An appropriate inform may resolve this question as well as being an appropriate reply • Similarly, a commit or a refuse utterance may resolve and reply to a request • The performance of the act to which an agent has committed completes that commitment peer-to-peer and agent-based computing

18. Dooley Graphs: Example B 1 3 A 4 2 1 C 5 RT: Replies to RE: Resolves C: Completes I: Index Participants = {A, B, C} peer-to-peer and agent-based computing

19. Dooley Graphs: Strengths • Extends advantages of FAs: • Participants involved & states of conversation clearly identified • Captures multiple threads of interaction • Relations between utterances not limited to precedence • E.g. an utterance can resolve a commitment made by another • Potential for exception handling peer-to-peer and agent-based computing

20. Dooley Graphs: Limitations • No representation of agent groups • No quantification over groups of agents • Specific utterances may be sent to multiple recipients, though • Scalability: Realistic conversations can be complex • “Spaghetti” diagrams • Maintenance difficulties peer-to-peer and agent-based computing

21. Electronic Institutions • Formalism to specify global protocols • At the lowest level, it uses FAs • Sophisticated protocols are broken down into simpler ones with some “coherence” • Simplest protocols are called “scenes” peer-to-peer and agent-based computing

22. Electronic Institutions (Cont’d) inform(buyer,seller,offer(10)) inform(buyer,seller,not_ok) inform(buyer,seller,ok) • Formalism for specifying MASs (and agents) • Non-deterministic finite-state machine • Labels are illocutions si sj peer-to-peer and agent-based computing

23. Electronic Institutions (Cont’d) Entry point Exit point Initial state Final state 0 3 1 2 w0 w1 w2 • Components: • Scenes – where interactions take place • Transitions – connections among scenes • Roles (of a scene) – generic label for agents • Sample scene (graphic format): agora room peer-to-peer and agent-based computing

24. Electronic Institutions (Cont’d) t2 t3 Agora Room Admission Settlement t4 t1 Departure Root Scene Output Scene Transitions • Sample EI (graphic format): peer-to-peer and agent-based computing

25. Electronic Institutions (Cont’d) • EIs – rich, expressive formalism: • Scenes provide self-contained modules • Transitions prescribe conditions for agents to move among scenes • Roles are generic identifiers for agents peer-to-peer and agent-based computing

26. Electronic Institutions (Cont’d) Institution Manager Tuple Space Rules of Behaviour Governor Scene Manager External agent Electronic Institution Governor Information Models Scene Manager External agent … … … Governor Scene Manager External agent … Transition Manager Transition Manager Transition Manager A distributed implementation: peer-to-peer and agent-based computing

27. Electronic Institutions (Cont’d) • Demo: peer-to-peer and agent-based computing

28. Unresolved Limitations • Scalability • Number of participants • Number of possible states • Maintenance • Extending and combining existing conversation protocols • Flexibility • Movement between conversations peer-to-peer and agent-based computing

29. FIPA Protocols FIPA protocol specifications: • Request Interaction • Query Interaction • Request When Interaction • Contract Net Interaction • Iterated Contract Net Interaction • English Auction Interaction • Dutch Auction Interaction • Brokering Interaction • Recruiting Interaction • Subscribe Interaction • Propose Interaction Available at http://www.fipa.org/repository/ips.php3 peer-to-peer and agent-based computing

30. FIPA Protocols (Cont’d) Request Interaction Protocol (IP) • Two agents: • Initiator • Participant • Initiator agent requests a Participant agent to perform some action • Participant agent processes request • Decides to agree or refuse request • If decision is refuse, then “refused” becomes true & Participant sends refuse • Otherwise, “agreed” becomes true and Participant sends agree peer-to-peer and agent-based computing

31. FIPA Protocols (Cont’d) • The Contract Net (CNET) protocol: • High-level protocol for cooperation through task sharing • Inspired by the way companies put out contracts: • Agent starts up the protocol when it recognises it cannot carry out some task. • Agent communicates with other agents and advertises a task announcement, then acts as a manager of that task • Broadcast, a limited broadcast or point-to-point messaging • Agents listen to the task announcements and evaluate them with respect to their capabilities and resources • When they find a task suited to them, they place a bid • A bid indicates what the agent can do and the associated costs • The manager receives all the bids and selects the one(s) it prefers or needs and tells the agents of its decision. peer-to-peer and agent-based computing

32. Communication protocols (Cont’d) I have a problem… (a) Recognising the problem (b) Task announcement (c) Bidding (d) Awarding the contract • The Contract Net (CNET) protocol: peer-to-peer and agent-based computing

33. FIPA Protocols (Cont’d) Contract Net Interaction Protocol: • Standardised by FIPA • One-to-many protocol • Extended UML peer-to-peer and agent-based computing

34. Suggested Reading • Agent Communication Languages: The Current Landscape. Y. Labrou, T. Finin, & Y. Peng. IEEE Intell. Systems, March/April 1999. http://doi.ieeecomputersociety.org/10.1109/5254.757631 • Agent Communication Languages: Rethinking the Principles. M. P. Singh. IEEE Computer. Dec. 1998. http://www.csc.ncsu.edu/faculty/mpsingh/papers/mas/computer-acl-98.pdf • Agent Communication Languages. T. Finin & Y. Labrou. Tutorial ASA/MA. 1999. http://www.cs.umbc.edu/~finin/papers/asama99tutorial.pdf peer-to-peer and agent-based computing