This study presents a framework to allow human and machine agents to reason and coordinate actions without direct communication mechanisms by sharing distributed Linked Data resources. This framework addresses the problems of querying frequently-updating distributed datasets and guaranteeing consistency in case of concurrent updates. The motivation for this framework comes from the use-case of opportunistic automation of humans-generated procedures. This use-case is based on existing real-world Linked Data representations of human instructions and their integration with machine functionalities.
human agent human agent interface interface
LD LD collective knowledge
LD LD machine agent machine agent automation to the case of multiple agents and decentralised resources. Given the high frequency of updates of the Linked Data resources used for communication, this scenario presents new challenges to traditional distributed query approaches. Also, the potentially small size and decentralisation of these resources make it an ideal application scenario for dynamic Linked Data discovery at runtime. 2
The proposed framework addresses the problem of allowing a collaborative set of human and machine agents, who can publish and access web resources but that cannot directly interact with each other, to communicate and coordinate their actions to collaboratively achieve tasks. As depicted in Figure 1, agents can access the resources of the other agents, but can only modify their own. No centralised resource which multiple agents can modify is available. In this context, communication refers to the process by which agents can propagate information (i.e. triples) to the other agents by modifying the collective knowledge, namely the resources that all agents can access. Coordination instead refers to the ability to guarantee certain conditions across all datasets. For example, coordination might be required to ensure that no agent starts executing a task which is already being executed by another agent. To simplify and isolate the problem at hand it is assumed that the agents involved already know and trust each other. Issues such as agent discovery, coalition formation and trust are considered as outside the scope of this project. 3 3.1
In order communicate meaningfully, a shared knowledge representation format needs to be established. Following the Linked Data principles, agents represent their knowledge as rdf statements and agree on a shared vocabulary. If this is not the case, additional techniques could be used. For example, knowledge extraction tools could generate an rdf representation of unstructured data and ontology alignment tools could be used to make di erent vocabularies interoperable.
One of the main challenges to enable communication between humans and
machine agents is the representation of knowledge in a format which is both
human and machine understandable. It is therefore important to map such
representation on the one hand to a logical formalism, so as to allow machine
reasoning, while on the other hand to an intuitive representation, such as in natural
language, which can be understood by humans. In the human-machine
collaboration scenario the prohow4 vocabulary is adopted. This vocabulary represents
tasks in terms of instructions and of their execution and it can be translated
both into a natural language representation and into logical statements [
Having decided on a shared knowledge representation format, agents communicate by storing data in their own repositories. The preferred method of doing so is by using dereferencable uris. For example, the uri for a certain task could resolve to an html document containing human understandable instructions on how to achieve the task, along with embedded machine understandable rdfa data. Content negotiation can also be used to serve human understandable documents to human users, and data les, such as rdf/xml data, to machine agents.
Dereferencable uris allow users to retrieve human understandable representations of entities using web browsers. More complex human interactions, however, require dedicated applications, here called interfaces. Human agents interact with the collective knowledge through interfaces which allow them both to consume and generate Linked Data. Both interfaces and machine agents can retrieve the collective knowledge of all the other agents locally to reason over it. In order for this to happen, agents need to know the uris of the datasets of the other agents. Knowledge of whether the others agents are humans or machines, or how to interact with them directly, is not required. In order to keep the collective knowledge up to date, agents need to locally retrieve the datasets of the other agents on a frequent basis, since datasets are constantly updated as the state of the collaboration evolves. This fact imposes practical constraints on the amount of data that agents can share during their collaboration.
Interfaces also require server-side functionalities in order to publish and update Linked Data. For example, a human agent might use an interface to describe how a certain task can be completed. An interface might then translate the user input (e.g. natural language instructions) into rdf and then publish it online. Interfaces should also translate user actions, such as a click on a check-box to de ne a step of a procedure as \complete", into corresponding rdf statements. 3.3
Coordination between agents might require them to verify certain conditions before a statement is communicated. For example, an agent a collaborating with 4 http://w3id.org/prohow t2: search
LD1 t4: add serialised update x
t7: if no conflicts, add x two other agents might be allowed to declare its intention s to accomplish a certain task only under a condition c that no other agent is already planning to do so. A possible approach to ensure such conditions is illustrated in Figure 2. Agent a might start by retrieving Linked Data from all the knowledge bases to determine if condition c is met (timepoints t1 to t3). Even if the condition appears to be satis ed, agent a cannot declare statement s yet as the other agents, in the meanwhile, could have updated their own datasets and invalidated c. The proposed approach to solve this problem is for agent a to write statement s in a \provisional" format (timepoint t4) using rdf rei cation, exploiting the fact that rei ed triples do not entail the triples. Rei cation provides a unique identi er for each triple, which can be annotated with the timestamp of its creation. Agent a would then access the other agent's knowledge bases a second time to verify if condition c still holds (timepoints t5 and t6). The agent will also consider the provisional statements written by the other agents before s was added in provisional form (before t4) but ignore the ones written after. After accessing the collective knowledge base a second time, agent a will add statement s in its repository only if condition c still holds (timepoint t7). This approach ensures that con icting statements are written on a rst-come rst-served basis. 4
This work presents a framework to allow human and machine agents to collaborate without directly communicating with each other. Linked Data is used as an indirect communication mechanism where agents communicate by publishing and accessing distributed resources. Issues arise as resources used to collaborate need to be frequently updated. Approaches are discussed to ensure that updates are quickly propagated to all the agents and that concurrent ones do not violate global constraints. Knowledge about processes and their execution is represented in an existing format which is both human and machine understandable.