# Yggdrasil: An Artifact-Based Framework for Hypermedia Multi-Agent Systems

Andrei Ciortea, Matteo Castellucci, Kai Schultz, Jérémy Lemée, Danai

Vachtsevanou, Fabien Gandon, Simon Mayer, Valentin Berger, Samuele

Burattini, Alessandro Ricci, et al.

► To cite this version:

Andrei Ciortea, Matteo Castellucci, Kai Schultz, Jérémy Lemée, Danai Vachtsevanou, et al. Yggdrasil: An Artifact-Based Framework for Hypermedia Multi-Agent Systems. Agents and Multi-Agent Systems Development, Springer Nature Switzerland, pp.181-207, 2026, 10.1007/978-3-032-01082-7_7. hal-05460210

HAL Id: hal-05460210

https://inria.hal.science/hal-05460210v1

Submitted on 15 Jan 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
# Yggdrasil: An Artifact-Based Framework for Hypermedia Multi-Agent Systems

Andrei Ciortea, Matteo Castellucci, Kai Schultz, Jérémy Lemée, Danai Vachtsevanou, Fabien Gandon, Simon Mayer, Valentin Berger, Samuele Burattini, Alessandro Ricci, and Olivier Boissier

**Abstract** Recent years have brought renewed interest in Web-based Multi-agent Systems (MAS), primarily motivated by progress in the Web of Things, Distributed Knowledge Graphs, and Generative AI. Central to these developments is the *flexible, autonomous use of hypermedia*—for example, to discover knowledge, invoke device functionality, or use tools. However, existing frameworks for Web-based MAS typically lack support for working with hypermedia abstractions and controls. To fill this gap, this chapter presents a model and framework for hypermedia-based MAS. Our specific focus is on the environment as a first-class abstraction in MAS: agents are situated and embodied in a distributed hypermedia environment that (i) provides them with a uniform abstraction of the system and (ii) is instrumented with tools and resources they can discover and use to achieve their goals. Given a single entry point into the hypermedia environment, agents are enabled to “arrive-and-operate”: they use their prior knowledge and experience to achieve their goals by browsing hypermedia and exploiting action possibilities discovered at run time—mimicking how humans are supported by well-designed hypermedia environments today. We illustrate our approach through a demonstrator and discuss its benefits and drawbacks against an equivalent implementation without hypermedia.

A. Ciortea
School of Computer Science, University of St.Gallen, St. Gallen, Switzerland

Inria, Université Côte d'Azur, CNRS, Sophia Antipolis, France
e-mail: andrei.ciortea@unisg.ch

M. Castellucci · S. Burattini · A. Ricci
Department of Computer Science and Engineering, Alma Mater Studiorum University of
Bologna, Bologna, Italy

K. Schultz · J. Lemée · D. Vachtsevanou · S. Mayer · V. Berger
School of Computer Science, University of St.Gallen, St. Gallen, Switzerland

F. Gandon
Inria, Université Côte d'Azur, CNRS, Sophia Antipolis, France

O. Boissier
MINES Saint-Étienne, Univ. Clermont Auvergne, INP Clermont Auvergne, CNRS,
Saint-Étienne, France
## 7.1 Introduction

Web-based Multi-agent Systems (MAS) have received significant attention over the years, going back to the early 2000s and the advent of service-oriented computing [56]. Recent years brought renewed interest in this topic, as evidenced by the Dagstuhl Seminar 21072 (February 2021),<fnref n="1" /> Dagstuhl Seminar 23081 (February 2023),<fnref n="2" /> and the W3C Autonomous Agents on the Web (WebAgents) Community Group (created in March 2023).<fnref n="3" /> This renewed interest is driven by progress in the Web of Things (WoT), distributed knowledge graphs, and generative AI: the WoT [34, 41, 64] unlocks new practical use cases for agents on the Web [16], implementing several visionary ideas expressed in the motivating scenarios from the original Semantic Web paper [3]; distributed knowledge graphs promote autonomy [8] and decentralization on the Web [52]; and advances in language models that can follow instructions and use tools bring new capabilities and attention to autonomous agents [44], enabling innovation and rapid prototyping at an unprecedented rate. Another key development, we argue, is the evolution of agent-oriented software engineering (AOSE) to consider explicitly multiple conceptual dimensions for MAS: not just the agents but also their environment, interaction, and organization [5, 20]. This view opens new avenues for the conceptual integration between architectures for MAS and the Web architecture [16].

In previous work, we built on the design of the Web architecture to propose a hypermedia-based design rationale for a novel class of worldwide, open, and long-lived MAS—which we refer to as *Hypermedia MAS (hMAS)* [13]. Several other initiatives have also investigated the use of hypermedia for designing Web-based MAS—either directly [11, 18] or indirectly through the use of Linked Data [7, 21]. However, existing frameworks and platforms for MAS typically lack proper support for working with hypermedia abstractions and controls. First, agents need support for freely browsing hypermedia and exploiting the environmental actions discovered in the process. Any assumptions hard-coded into agents at design time about environmental actions available at run time, as is usually the case in AOSE,<fnref n="4" /> are likely to break in a dynamic hypermedia environment. Second, similarly to how humans are supported by well-designed hypermedia environments today, agents also require hypermedia environments instrumented with the tools and resources they need to achieve their design objectives—which emphasizes the role of the *environment as a first-class abstraction* in hMAS [62].

In this chapter, we present the Yggdrasil model and framework for designing and programming hMAS. Yggdrasil addresses a set of open and current issues, such as

<footnote n="1">¹ https://dagstuhl.de/21072</footnote>

<footnote n="2">² https://dagstuhl.de/23081</footnote>

<footnote n="3">³ https://www.w3.org/community/webagents/</footnote>

<footnote n="4">⁴ For example, when programming a BDI agent using AgentSpeak, the repertoire of environmental actions is assumed to be known at design time.</footnote>
agent identification, representation, and embodiment on the Web<fnref n="5" />—and in a manner that is aligned with the Web architecture and best practices for the Semantic Web. Similarly to the W3C Linked Data Platform [57], Yggdrasil creates and manages a hypermedia-based abstraction layer that reflects the state of a MAS deployed using the framework. Our specific focus is on the environment as a first-class design and programming abstraction in MAS: agents are *situated* and *embodied* in a distributed hypermedia environment that (i) provides them with a uniform abstraction of the system and (ii) is instrumented with the tools and resources they need to achieve their design objectives. Given a single entry point into an *unknown* hypermedia environment, agents then browse hypermedia to discover and interact with the rest of the MAS. We show that this design rationale minimizes coupling in the MAS, promotes openness and evolvability, and facilitates the distribution of MAS across the Web [13].

We discuss related work on Web-based MAS in Sect. 7.2. We then present our approach in Sect. 7.3 and the implementation of our framework in Sect. 7.4. To further support our approach, in Sect. 7.4, we also introduce a library of CArtAgO artifacts [50] for programming Jason agents [5] in hypermedia environments and report on a prototypical hypermedia search engine that allows agents to perform approximate search queries in weak real time.<fnref n="6" /> In Sect. 7.5, we then demonstrate our approach in a producer/consumer scenario with two Jason agents situated and embodied in a hypermedia environment distributed across three Yggdrasil nodes. We use this demonstrator to discuss the benefits and drawbacks of our approach against an equivalent baseline implementation without hypermedia. The demonstrator and all software components are available on GitHub.<fnref n="7" />,<fnref n="8" />,<fnref n="9" />,<fnref n="10" />

## 7.2 Background and Related Work

In Sect. 7.2.1, we present core ideas underpinning our approach from the hypermedia-based design of the Web architecture—and their application to Linked Data and the WoT. We then discuss related work on Web-based MAS in Sect. 7.2.2, including a few recent initiatives to design hMAS.

<footnote n="5">⁵ See the report of the Dagstuhl Seminar 23081 [6].</footnote>

<footnote n="6">⁶ The initial implementation of the hypermedia search engine was published in [15].</footnote>

<footnote n="7">⁷ Demonstrator: https://github.com/andreiciortea/eumas-toolkit-demo/.</footnote>

<footnote n="8">⁸ The Yggdrasil framework: https://github.com/interactions-HSG/yggdrasil.</footnote>

<footnote n="9">⁹ JaCaMo-hypermedia: https://github.com/hyperagents/jacamo-hypermedia.</footnote>

<footnote n="10">¹⁰ Search engine: https://github.com/interactions-HSG/wot-search.</footnote>
### 7.2.1 REST, Linked Data, and the Web of Things

The Web has been highly successful as a worldwide, open, and long-lived system— and its huge success comes from its carefully designed architectural properties. One of the central features of the Web is having a uniform interface between loosely coupled components. This feature is induced by REST, the architectural style of the Web, particularly through the *Uniform Interface* constraint [24]. In REST, components interact by transferring representations of resources, where a *resource* is the key abstraction of information: anything that can be named can be a resource, the preferred naming scheme being Internationalized Resource Identifiers (IRIs). The *representation* of a resource is a sequence of bytes plus metadata that describes its format, i.e., an Internet media type.<fnref n="11" /> Components then perform one of a small set of well-defined methods on a resource to obtain a representation. The methods and media types are standard and uniform across components, hiding away their internal operations and raw data formats. Then, to further reduce coupling between components, REST uses hypermedia to drive interaction in the system [24]: origin servers advertise hypermedia controls that encapsulate the information required to request application-specific transitions to new states. Hypermedia-driven interaction is a core tenet of REST and central to decoupling the interaction between Web components: given a single entry point into the Web, a browser can navigate freely across origin servers.

Standard media types support uniform interaction on the Web at the cost of having to hard-code their meaning into components. In addition, the Semantic Web provides a standard graph data model known as the Resource Description Framework (RDF). Components use standard RDF serialization formats and rely on ontologies<fnref n="12" /> and thesauri<fnref n="13" /> to identify and define concepts and relations shared across RDF representations and across datasets. Going further, the rules of Linked Data [4] prescribe best practices and a uniform interface that components can follow to publish and access RDF data on the Web.<fnref n="14" /> Perhaps the most concrete realization of this uniform interface is the Linked Data Platform [57], which defines an HTTP-based protocol for reading and writing Linked Data. The Linked Data Platform provides uniform access to containers of RDF documents and the documents themselves. It enforces linking across RDF documents to create and manage distributed knowledge graphs [35]. Linked Data can thus be seen as the first deployment wave of the Semantic Web [26]: it enables software agents to explore Web environments [27, 28] by browsing a machine-friendly Web in a similar manner to how humans browse the human-friendly part of the Web.

<footnote n="11">¹¹ See: https://www.iana.org/assignments/media-types/media-types.xhtml.</footnote>

<footnote n="12">¹² For example, defined in RDF Schema (RDFS) or the Web Ontology Language (OWL).</footnote>

<footnote n="13">¹³ For example, defined using the Simple Knowledge Organization System (SKOS).</footnote>

<footnote n="14">¹⁴ We refer the interested reader to [47] for a comparison between REST's Uniform Interface constraint and the rules of Linked Data.</footnote>
The idea of a hypermedia-based uniform interface extended beyond the Web of Data to the Web of Things (WoT) [64]. For example, the W3C Recommendation for the WoT Thing Description [39] relies on hypermedia controls to hide the protocols and interfaces used to access device functionality behind abstract interaction patterns. In contrast to the Linked Data Platform, this approach relaxes the strict use of a well-defined set of methods for uniform interaction. Instead, all heterogeneity is encapsulated by hypermedia controls. Furthermore, the abstract interaction patterns go beyond the synchronous interaction ingrained in the classical Web model to promote asynchronous interaction—for example, based on the publish/subscribe mechanism built into the Constrained Application Protocol (CoAP) [55]<fnref n="15" /> or the W3C WebSub protocol [30]. We refer the interested reader to [40] for a discussion on extending REST for asynchronous interaction and decentralized systems.

### 7.2.2 From Web-Based MAS to Hypermedia MAS

Since the early 2000s, there has been extensive research on Web-based MAS. Most notably, with the advent of service-oriented computing, Michael Huhns and Munindar P. Singh promoted a broader perspective that would integrate MAS and the Web at a conceptual level [56]. Most of the early research was influenced by service-oriented architectures based on the main standards for Web services available at the time (the WS-* standards: SOAP, WSDL, UDDI, etc.) [31, 36]. However, the WS-* standards use the Web only as a transport layer: they are agnostic to its design and the use of hypermedia. The Foundation for Intelligent Physical Agents (FIPA) also proposed a specification for using HTTP as a transport protocol for messages exchanged among agents [25], which was implemented by several FIPA-compliant platforms (e.g., [22, 23, 33]). MAS frameworks and platforms that use the Web as a transport layer are misaligned with the Web architecture—and provide little support (if any) for working with hypermedia.

More recent approaches have turned to resource-oriented architectures inspired by REST that implement Create-Read-Update-Delete (CRUD) operations over HTTP (e.g., [1, 32, 45]), but they generally do not use hypermedia-driven interaction, which leads to tight coupling in the resulting MAS. In this context, Ciortea et al. [16] propose Hypermedia MAS (hMAS) as a new class of Web-based MAS following more closely the hypermedia-based design of the Web architecture. A few initiatives have investigated the use of hypermedia for designing Web-based MAS—either directly, or indirectly through the use of Linked Data. For example, Calbimonte et al. [7] propose to use W3C Linked Data Notifications [9] as a mechanism for interaction in Web-based MAS. Dikenelli et al. [21] propose an environment architecture to integrate MAS with the Linked Open Data Cloud.<fnref n="16" />

<footnote n="15">¹⁵ CoAP is a Web transfer protocol for constrained devices.</footnote>

<footnote n="16">¹⁶ https://lod-cloud.net/, accessed: 26.05.2025.</footnote>
Ciortea et al. [13] propose a set of principles for using hypermedia to design Web-based MAS, where the environment dimension is used as a conceptual bridge between architectures for MAS and the Web architecture. Charpenay et al. [11] propose a formal framework for agent-environment interaction based on REST. O'Neill et al. [46] consider deploying agents as entities co-existing in a hypermedia space with the goal of driving adoption of AOSE by embedding MAS within microservices (rather than making them visible to the outside world). These initiatives investigate new perspectives on using hypermedia to design Web-based MAS, but to our knowledge, existing frameworks and platforms for designing and programming MAS lack proper support for using hypermedia abstractions.

The work we present in this chapter is an extension of the design rationale introduced in [13]: we maintain the same general design principles introduced in [13], but we refine their application to the Agents and Artifacts meta-model [49], which is the conceptual underpinning of Yggdrasil. That paper also presented an initial proof-of-concept of the Yggdrasil framework, but in a very limited form—only as a repository of semantic descriptions. Several of the contributions presented in this chapter (e.g., agent bodies, virtual hypermedia artifacts) were not yet conceived at that time.

## 7.3 Artifact-Based Hypermedia Environments

In this section, we present the Yggdrasil<sup>17</sup> framework for designing and programming artifact-based hypermedia environments. The specific focus of our approach to designing hMAS is on the environment as a first-class design and programming abstraction [49, 62]: the hypermedia environment is a design space that can be exploited to provide agents with various levels of support, such as mediating access to their deployment context, discovering and interacting with other agents, or shaping their environment to better suit their design objectives. This separation of concerns between agent and environment responsibilities is central for a conceptual integration with the Web architecture—turning the Web into an application layer for MAS and a place for mediated interaction through shared resources. Furthermore, it allows agents and components in their environment to be developed, deployed, and to evolve independently from one another.

In contrast to other MAS frameworks, a distinctive property of an environment developed with Yggdrasil is that it provides agents with a *uniform hypermedia-based abstraction layer* of their system. This abstraction layer effectively decouples agents from the rest of the MAS and enables system-wide discovery via crawling: given a single entry point into a distributed environment, agents can navigate hypermedia to discover and interact with the rest of the system. To achieve

<footnote n="17"><sup>17</sup> Yggdrasil is a mythical tree that interconnects the nine worlds in Norse mythology. We chose this name as a metaphor for using hypermedia to interconnect the virtual and physical worlds.</footnote>
<figure><img src="image_2.png" /><figcaption>**Fig. 7.1** A simplified overview of an ontological model for artifact-based hypermedia environments. We omit namespace prefixes for legibility. All properties have corresponding inverse properties (e.g., `hmas:isContainedIn`)</figcaption></figure>

this, the abstraction layer is represented as a *distributed knowledge graph* [35]: it provides agents with a knowledge-level abstraction of the MAS that hides the lower-level details of their deployment context behind semantic models and hypermedia controls. From an agent's viewpoint, the set of all environmental actions is determined by the hypermedia controls discovered at run time. Such actions include intentional focus, that is, actions for observing relevant state changes and other events in the environment.

In what follows, we first provide an overview of the main features of artifact-based hypermedia environments developed with Yggdrasil. Then, we present the uniform abstraction layer in more detail and explain how Yggdrasil captures and manages the state of a MAS through linked RDF documents. Finally, we present how developers can program virtual hypermedia artifacts, which agents can instantiate at run time to instrument their environment with the functionality they need to achieve their design objectives.

### 7.3.1 Agents, Artifacts, and Hypermedia

Figure 7.1 illustrates the ontological model we use for artifact-based hypermedia environments, which builds on the *Hypermedia MAS (hMAS)* core ontology [14]. We adopt abstractions from the *Agents and Artifacts (A&A)* meta-model [49] and reinterpret them following the hypermedia-based design rationale introduced in [13]. The environment is modeled through *hypermedia-based workspaces*, which are logical containers for agents, artifacts,<fnref n="18" /> and any other resources agents might use in their activities. In this context—and in line with the Web architecture [38]—a *resource* is anything that can be named, including agents, artifacts, or any relevant

<footnote n="18">¹⁸ In A&A, artifacts are computational entities that agents can instantiate, share, and use. Artifacts capture the nonautonomous, function-oriented behavior in the system [5].</footnote>
Web resources. A workspace can also contain or link to other workspaces, which may be distributed across multiple Yggdrasil nodes. As such, workspaces provide a notion of *locality* in the distributed hypermedia environment, one that is domain- or application-specific and not necessarily tied to physical distribution: depending on the system's design requirements, workspaces may or may not reflect in the hypermedia environment information about their geographical location or other deployment-related information.

A facility offered by Yggdrasil that is especially important in open hypermedia environments is *embodiment* (e.g., see [67]). Following the A&A meta-model, agents may join, leave, and work in multiple workspaces simultaneously (cf. [49]). When an agent *joins* a workspace, the agent is reified in that workspace through an explicit representation of its *body*, which in our model is a type of artifact contained in a workspace (cf. Fig. 7.1). Body artifacts allow heterogeneous agents, which may be implemented using different models and frameworks, to be reified in a uniform way within the same hypermedia-based workspace. Furthermore, the explicit representation of agent bodies allows agents to discover one another and observe each other's actions. The latter is central to supporting not only accountability but also implicit communication through behavior (see [58]). Finally, agents may also use their bodies to expose various action *possibilities* to other agents—these possibilities may depend on the other party or the deployment context (e.g., other artifacts in the workspace the agents' bodies are reified in). For example, an agent may prefer different modalities for interacting with different agents, or an agent operating the Heating, Ventilation, and Air Conditioning (HVAC) system of a building may expose specific request options only in a workspace for administrators.

Another facility offered by Yggdrasil and inspired by the A&A meta-model is to provide agents with a *reflective level of support*: agents may shape the distributed hypermedia environment to better suit their own design objectives—and they can do so by creating workspaces, instantiating artifacts, or weaving hypermedia. For example, an agent can create a hypermedia-based workspace to define a new context for an activity. The agent can then add functionality to the workspace either by (i) registering external devices and services as hypermedia artifacts within the workspace (see Sect. 7.3.2) or (ii) instantiating virtual hypermedia artifacts (see Sect. 7.3.3). Furthermore, agents can weave hypermedia overlays by creating links across workspaces and adding metadata to support resource discovery and information dissemination (e.g., similar to [17]).

### 7.3.2 A Uniform Abstraction Layer

Central to designing a uniform hypermedia-based abstraction layer is the identification and representation of resources. All resources in an hMAS deployed with Yggdrasil are modeled either as *information resources* or *non-information resources*. In the Web architecture, an *information resource* is any resource whose “essential characteristics can be conveyed in a message” [38], such as RDF documents.
ments. Conversely, *non-information resources* are resources that can be described but cannot be conveyed in a message, such as people, devices, and abstract concepts [53]. We model most entities of interest in an hMAS as non-information resources, including agents, workspaces, and artifacts (cf. previous section). We then use RDF documents, which we call *resource profiles* (cf. Fig. 7.1), to capture the descriptions and relations among those entities, forming the backbone of the hypermedia-based abstraction layer. For example, when an agent joins a hypermedia-based workspace, the RDF document describing that workspace is updated to reflect this change. Yggdrasil provides the features required to identify, locate, and manage information and non-information resources in an hMAS.<fnref n="19" />

All resources managed by Yggdrasil are identified by IRIs. This design decision promotes distribution transparency in hMAS: IRIs have a global scope and can thus be referenced independently from the context in which they are used. Non-information resources are identified by *hash IRIs* (see [53]): we use a fragment identifier to identify a non-information resource (e.g., an agent) relative to the information resource describing it (e.g., the agent's profile). Then, when dereferencing the IRI of a non-information resource, Yggdrasil returns a representation of the RDF document describing it. For example, Listing 7.1 shows a simplified description of an agent, which includes two non-information resources: the agent itself with the fragment identifier `#agent` (line 10) and its body with the fragment identifier `#artifact` (line 6). Yggdrasil returns this description when dereferencing either the agent's IRI or the body's IRI: fragment identifiers are stripped away before dereferencing the IRIs, so in both cases, the IRI being requested identifies the RDF document describing the agent's body. An agent may have multiple bodies in different workspaces, but the agent's IRI dereferences to a single authoritative description set by the agent.

<caption>**Listing 7.1** A description of agent *alice* and its body artifact</caption>

```R
@base <http://localhost:8080/> .
@prefix hmas: <https://purl.org/hmas/> .
@prefix td: <https://www.w3.org/2019/wot/td#> .
@prefix jacamo: <https://purl.org/hmas/jacamo/> .

<workspaces/production/artifacts/alice/# artifact> a td: Thing, hmas: Artifact, jacamo: Body;
    hmas: isContainedIn <workspaces/production/# workspace>;
    jacamo: isBodyOf <workspaces/production/artifacts/alice/# agent> .

<workspaces/production/artifacts/alice/# agent> a hmas: Agent .
<workspaces/production/# workspace> a hmas: Workspace .
```

<footnote n="19">¹⁹ This is similar to how the Linked Data Platform manages RDF documents for the Web of Data (cf. Sect. 7.2.1). Our approach, however, is tailored to hMAS.</footnote>
<caption>**Listing 7.2** A simplified description of an Yggdrasil node</caption>

```yaml
@base <http://localhost:8080/>.
@prefix hmas: <https://purl.org/hmas/>.
@prefix jacamo: <https://purl.org/hmas/jacamo/>.
@prefix wotsec: <https://www.w3.org/2019/wot/security#>.
@prefix htv: <http://www.w3.org/2011/http#>.
@prefix hctl: <https://www.w3.org/2019/wot/hypermedia#>.
@prefix td: <https://www.w3.org/2019/wot/td#>.

<#platform> a td:Thing, hmas:HypermediaMASPlatform;
    td:title "Yggdrasil{} Node";
    hmas:hosts <workspaces/production/#workspace>;
    td:hasSecurityConfiguration [ a wotsec:NoSecurityScheme ];
    td:hasActionAffordance [ a td:ActionAffordance, jacamo:CreateWorkspace;
    td:name "createWorkspace";
    td:hasForm [
        htv:methodName "POST";
        hctl:hasTarget <workspaces/>;
        hctl:forContentType "application/json";
        hctl:hasOperationType td:invokeAction
    ]
].

<workspaces/production/#workspace> a hmas:Workspace.
```

Yggdrasil generates RDF representations using the hMAS core ontology [14], which supports the design rationale for hMAS introduced in [13]. For example, the hMAS core ontology promotes hypermedia-driven discovery through relations such as `hmas:hosts` (e.g., between an hMAS platform and a workspace it hosts) and `hmas:contains` (e.g., between a workspace and an agent, artifact, or sub-workspace it contains). These relations are illustrated in Fig. 7.1. Yggdrasil then enforces navigability by managing corresponding triples as a side effect of agents acting in the hMAS. For example, when an agent creates a root workspace, Yggdrasil creates a corresponding `hmas:hosts` triple (see line 11 in Listing 7.2). Similarly, when an agent joins a workspace, Yggdrasil creates a corresponding `hmas:contains` triple (see line 9 in Listing 7.3). Triples using the inverse properties (i.e., `hmas:isHostedOn` and `hmas:isContainedIn`) are also managed by Yggdrasil (see line 8 in Listing 7.3 and line 7 in Listing 7.1). Links across nodes can be created by updating descriptions of workspaces, artifacts, or agents. Currently, Yggdrasil does not manage such links—just like Web servers do not manage links across the Web to favor scalability over link consistency.

In addition to the hMAS ontology, representations can use other existing ontologies to represent action and perception possibilities—and the hypermedia controls required to use them. For example, Listing 7.2 uses the W3C WoT Thing Description (TD) ontology [12] to represent an Yggdrasil node both as an `hmas:HypermediaMASPlatform` and a `td:Thing`—and shows a hypermedia control an agent can use to create a root workspace (lines 13–21). From this description, an agent can also discover that the node already hosts a root workspace (lines 11 and 23). Dereferencing the workspace’s IRI returns the representation shown in Listing 7.3, which includes hypermedia controls for participating in the workspace (e.g., to join the workspace, instantiate an artifact template, etc.).
<caption>**Listing 7.3** A simplified description of a workspace</caption>

```json
@base <http://localhost:8080/>
@prefix js: <https://www.w3.org/2019/wot/json-schema#> .
(...)

<workspaces/production/#workspace> a td:Thing, hmas:Workspace;
td:title "production";
td:hasSecurityConfiguration [ a wotsec:NoSecurityScheme ];
hmas:isHostedOn <#platform>;
hmas:contains <workspaces/production/artifacts/source/# artifact>,
  < <workspaces/production/artifacts/alice/# artifact> ;
td:hasActionAffordance [ a td:ActionAffordance, jacamo:JoinWorkspace;
td:name "joinWorkspace";
td:hasForm [
  htv:methodName "POST";
hctl:hasTarget <workspaces/production/join>;
hctl:forContentType "application/json";
hctl:hasOperationType td:invokeAction
]
], [ a td:ActionAffordance, jacamo:MakeArtifact;
td:name "makeArtifact";
td:hasForm [
  htv:methodName "POST";
hctl:hasTarget <workspaces/production/artifacts/>;
hctl:forContentType "application/json";
hctl:hasOperationType td:invokeAction
];
td:hasInputSchema [ a js:ObjectSchema;
  js:properties [ a js:StringSchema, jacamo:ArtifactTemplate;
    js:propertyName " artifactClass";
    js:enum ex:Source
  ], [ a js:ArraySchema, jacamo:InitParams;
    js:propertyName "initParams"
  ], [ a js:StringSchema, jacamo:ArtifactName;
    js:propertyName " artifactName"
  ];
  js:required " artifactClass ", " artifactName"
]
], (...).

<#platform> a hmas:HypermediaMASPlatform .
<workspaces/production/artifacts/source/# artifact> a hmas:Artifact .
<workspaces/production/artifacts/alice/# artifact> a hmas:Artifact, jacamo:Body.
```

Yggdrasil allows agents to enrich a workspace with new functionality by registering external devices and services as hypermedia artifacts within the workspace. For example, an agent can add a device to a workspace by registering a W3C WoT TD document describing it. Yggdrasil will validate the WoT TD document's syntax and create the containment triples required to make it discoverable, but will not perform any further validations (e.g., to check the semantic validity of the hypermedia controls).

### 7.3.3 Virtual Hypermedia Artifacts

In hMAS developed with Yggdrasil, the hypermedia environment is not just a design abstraction but also a programming abstraction: developers can program templates of virtual hypermedia artifacts, which agents can then discover, instantiate, and
use. The concept of a virtual hypermedia artifact is similar to an artifact in the A&A meta-model—and Yggdrasil integrates with the CArtAgO framework [49] to provide a runtime environment for virtual artifacts (see Sect. 7.4). The main difference is that when a virtual hypermedia artifact is instantiated, Yggdrasil exposes an HTTP interface for the artifact instance and generates an artifact profile, which is linked from the containing workspace (see line 9 in Listing 7.3). Other agents in the hMAS can then discover the artifact instance and the hypermedia controls required to interact with it.

<caption>**Listing 7.4** Example of a template for a virtual hypermedia artifact that produces random items</caption>

```java
public class Source extends HypermediaTDArtifact {
    private final Random random = new Random();

    @OPERATION
    public void produce( final OpFeedbackParam<Integer> item) {
        this .await_time(( this .random.nextInt(5) + 1) * 1_000);
        final var producedItem = this .random.nextInt(10);
        this .log("Item (" + producedItem + ") has been produced!");
        item. set(producedItem);
    }

    @Override
    protected void registerInteractionAffordances () {
        this .registerActionAffordance (
            " https://example.org/Produce ",
            "produce ",
            "produce ",
            null
        ,
        new ArraySchema.Builder()
            . growth(new IntegerSchema.Builder() .build())
            . build()
        );
    }
}
```

For example, Listing 7.4 shows the template of a virtual hypermedia artifact we use in our demonstrator to produce random items (see Sect. 7.5.1). The template is programmed similarly to an artifact template in CArtAgO [49]—and one of our objectives was to allow artifact developers already familiar with CArtAgO to use Yggdrasil with little overhead: it extends the HypermediaTDArtifact class, which is a subclass of the Artifact class in CArtAgO and provides access to the same API. In addition, however, extending the HypermediaTDArtifact class requires overriding a method for registering the artifact’s interaction affordances following the W3C WoT TD [39]. The specification is done programmatically (lines 12–23 in Listing 7.4) and is used by Yggdrasil to expose an HTTP interface with hypermedia controls for each artifact instance being created. As an alternative to using the W3C WoT TD, Yggdrasil supports defining artifact templates using the hMAS ontology and signifiers [59]. Artifact templates using signifiers are programmed similarly.

Agents can instantiate a virtual hypermedia artifact using a hypermedia control like the one shown in Listing 7.3 (lines 18–37). The hypermedia control allows agents to discover all the artifact templates supported by the Yggdrasil node on which the workspace is hosted. The node in this example supports only one template
identified by the ex:Source IRI (line 29 in Listing 7.3), which maps to the Java
class shown in Listing 7.4.

7.4 Implementation and Tooling

We present the architecture of the Yggdrasil framework in more detail in Sect. 7.4.1. Hypermedia environments developed with Yggdrasil expose a uniform interface that heterogeneous agents can access from anywhere in the world.<fnref n="20" /> The uniform interface is based on hypermedia controls and Web standards, but the agents’ logic should be insulated from the low-level details of parsing RDF representations like the one in Listing 7.3 or composing and issuing HTTP requests. This added complexity of using hypermedia can be mitigated with appropriate middleware. To this end, in Sect. 7.4.2, we present a library of CArtAgO artifacts that facilitates programming Jason agents [5] in distributed hypermedia environments.<fnref n="21" /> For example, using these artifacts, a Jason agent can browse hypermedia to find the resources it needs to achieve its goals. Still, browsing large-scale hypermedia environments would be inefficient. As an alternative, in Sect. 7.4.3, we report on a prototypical hypermedia search engine that agents can use to perform approximate search queries in weak real time. All software presented in this section is open-source and available on GitHub.<fnref n="22" />,<fnref n="23" />,<fnref n="24" />

7.4.1 The Yggdrasil Framework

Yggdrasil implements an asynchronous event-driven multithreaded architecture
based on Vert.x.<fnref n="25" /> The main components in a typical deployment of an Yggdrasil
node are shown in Fig. 7.2. The HTTP Server exposes a REST-style uniform
interface, usually accessed by an agent runtime environment (e.g., a Jason runtime
environment) on a remote node. Requests issued by agents are then dispatched to
the other components. The agent issuing a request can be identified across Yggdrasil
nodes using a decentralized authentication protocol. In the future, we intend to
implement the Solid-OIDC authentication protocol.<fnref n="26" /> In the current version of

<footnote n="20">²⁰ By heterogeneous agents, we mean agents developed using different architectures, frameworks, or programming languages.</footnote>

<footnote n="21">²¹ Similar libraries can be developed for other agent frameworks as well.</footnote>

<footnote n="22">²² The Yggdrasil framework: https://github.com/interactions-HSG/yggdrasil.</footnote>

<footnote n="23">²³ JaCaMo-hypermedia: https://github.com/hyperagents/jacamo-hypermedia.</footnote>

<footnote n="24">²⁴ Search engine: https://github.com/interactions-HSG/wot-search.</footnote>

<footnote n="25">²⁵ https://vertx.io/, accessed: 26.05.2025.</footnote>

<footnote n="26">²⁶ https://solidproject.org/TR/oidc, accessed: 26.05.2025.</footnote>
<figure><img src="image_3.png" /><figcaption>**Fig. 7.2** UML component diagram illustrating (i) the architecture of the Yggdrasil framework and (ii) a runtime environment for agents that can perceive and act upon a hypermedia environment deployed with Yggdrasil</figcaption></figure>

Yggdrasil, agents must specify in a custom HTTP header field their WebID,<fnref n="27" /> meaning an IRI that identifies the agent and dereferences to its profile. Most operations except anonymous browsing require identifying the agent accessing the hypermedia environment. If the agent fails to provide its WebID, a 401 Unauthorized status code is returned.

The knowledge graph hosted on a given node is managed by the RDF Store component, either in-memory or on disk for persistence. The CArtAgO Runtime component is responsible for running and managing operations on virtual artifacts— and uses an embedded instance of the CArtAgO framework [49]. All changes to the knowledge graph or events generated by the CArtAgO Runtime are dispatched to interested agents through W3C WebSub [30], a brokered publish/subscribe protocol based on HTTP. We use WebSub to enable *active perception* [63] in distributed hypermedia environments: agents can selectively perceive only those parts of the hypermedia environment relevant to their design objectives. To this end, agents (or their runtime environment) must register a callback IRI where they can receive notifications (see Fig. 7.2).

The *uniform interface* of a distributed hypermedia environment developed with Yggdrasil covers both *action* and *perception*: agents act on the environment in a uniform way by exploiting hypermedia controls, and they can selectively perceive the environment in a uniform way through W3C WebSub.

<footnote n="27">²⁷ https://www.w3.org/2005/Incubator/webid/spec/identity/</footnote>
## 7.4.2 A Library of Artifacts for Working with Hypermedia Environments

We developed a library of CArtAgO artifacts to support programming Jason agents that use hypermedia controls, browse hypermedia, and handle asynchronous notifications via W3C WebSub.<fnref n="28" />

**Listing 7.5** A Jason plan using the **ThingArtifact** to pick up a block with a PhantomX AX-12 Reactor robotic arm. The arm rotates around its base to reach a target position. For brevity, we omit **artifact_name** annotations on **invokeAction** calls

```javascript
1 +!pickUpBlock(RobotUri, TargetAngle) : true <-
2   makeArtifact("leubot", "org(...) ThingArtifact", [RobotUri], _);
3   setAPIKey(Token)[ artifact_name ("leubot") ];
4   // Rotate the arm to the target position of the block
5   invokeAction("onto:SetBase", ["onto:BaseJoint"], [TargetAngle]);
6   // Open the gripper
7   invokeAction("onto:SetGripper", ["onto:GripperJoint"], [512]);
8   // Lower the arm over the block at a predefined height
9   invokeAction("onto:SetWristAngle", ["onto:WristAngleJoint"], [390]);
10  invokeAction("onto:SetShoulder", ["onto:ShoulderJoint"], [510]);
11  // Close the gripper to grasp the block
12  invokeAction("onto:SetGripper", ["onto:GripperJoint"], [400]);
13  // Lift the arm with the block
14  invokeAction("onto:SetShoulder", ["onto:ShoulderJoint"], [400]).
```

The library encapsulates the low-level logic of using hypermedia controls in ** artifact stubs**. One example of stub is the **ThingArtifact**: a CArtAgO artifact that retrieves a W3C WoT TD document, such as the ones shown in Listing 7.2 and 7.3, to construct and issue HTTP requests based on the hypermedia controls discovered at run time. An agent instantiates a **ThingArtifact** with an IRI that dereferences to a valid TD document and can then invoke actions based on a semantic model of the described thing. For example, Listing 7.5 shows a Jason plan that creates a **ThingArtifact** (line 2) for controlling a PhantomX AX-12 Reactor robotic arm from Trossen Robotics. The robot is deployed in our laboratory's infrastructure and controlled through an HTTP interface that requires authentication with an API key (line 3).<fnref n="29" /> The robot's interface is defined in terms of joint parameters—and we assume the agent has a semantic model of the robot, which it uses to invoke actions for picking up a block from a target location (lines 5–14). The agent is thus programmed against the robot's semantic model but is decoupled from the robot's HTTP API, which is more likely to change.

Another stub is the **WorkspaceThingArtifact**: a subclass of **ThingArtifact** that an agent can use to interact with hypermedia-based workspaces modeled as shown in Listing 7.3. This artifact exposes observable properties with metadata of parent workspaces, child workspaces, and contained artifacts (incl. agent bodies). Agents can then use this metadata to browse the hypermedia environment. For

<footnote n="28">²⁸ The library currently supports the hMAS ontology [14] and the W3C WoT TD ontology [12] used in our deployments.</footnote>

<footnote n="29">²⁹ Authentication with API keys is supported by the W3C WoT TD [39].</footnote>
example, Listing 7.6 shows the complete set of plans implementing a simple strategy for crawling a hierarchy of workspaces starting from an arbitrary location (e.g., the agent's home workspace). The logic is concise because the low-level details are handled by **WorkspaceThingArtifact** stubs. The agent starts the search by loading its home workspace (lines 1–8). If the home workspace has a parent or a child workspace, the artifact stub will expose an observable property to be perceived by the agent. The agent then only needs to react to the discovery of parent (lines 10–12) and child workspaces (lines 14–16): when a new workspace is discovered, the agent loads it to continue the search recursively (lines 18–21).

<caption>**Listing 7.6** A simple strategy for crawling a hierarchy of workspaces starting from an arbitrary point in the hierarchy</caption>

```python
1 +!explore : homeWorkspace(HomeName, HomeWorkspaceIRI) & webid(MyWebID)
2 <- .print("My home workspace IRI is: ", HomeWorkspaceIRI);
3 +seen(HomeWorkspaceIRI, HomeName);
4 makeArtifact(HomeName, "org(...).WorkspaceThingArtifact", [HomeWorkspaceIRI],
5             ArtId);
6 focus(ArtId);
7 setOperatorWebId(MyWebID)[ artifact_id(ArtId) ];
8 joinHypermediaWorkspace[ artifact_id(ArtId) ];
9 +joinedWsp(HomeWorkspaceIRI).
10
11 +parentHypermediaWorkspace(ParentIRI, ParentName, _)
12 : not seen(, ParentName)
13 <- !loadWorkspace(ParentIRI, ParentName).
14
15 +hypermediaWorkspace(WorkspaceIRI, WorkspaceName, _)
16 : not seen(, WorkspaceName)
17 <- !loadWorkspace(WorkspaceIRI, WorkspaceName).
18
19 +!loadWorkspace(WorkspaceIRI, WorkspaceName) : not seen(, WorkspaceName)
20 <- makeArtifact(WorkspaceName, "org(...).WorkspaceThingArtifact", [WorkspaceIRI],
21             ArtId);
22 focus(ArtId);
23 +seen(WorkspaceIRI, WorkspaceName).
```

<caption>**Listing 7.7** An example stopping condition. The agent drops the search if it finds an artifact of a given type</caption>

```python
1 +hypermediaArtifact(ArtifactIRI, ArtifactName, SemanticTypes)
2 : .member("https://example.org/Source", SemanticTypes) & webid(MyWebID)
3 <- makeArtifact(ArtifactName, "org(...).ThingArtifact", [ArtifactIRI], ArtId);
4 setOperatorWebId(MyWebID)[ artifact_id(ArtId) ];
5 +source artifact(ArtifactIRI, ArtifactName, ArtId);
6 .drop intention(explore).
```

The simple crawling strategy in Listing 7.6 continues until the agent has explored the entire workspace hierarchy, but the agent could also implement a stopping condition. For example, Listing 7.7 shows a plan that stops the search if an artifact of a given type is found. The **WorkspaceThingArtifact** stub exposes an observable property for each artifact contained in the workspace (line 1), which includes a list of the artifact's semantic types (if any). If an artifact of type `ex:Source` (cf. Listing 7.4) is found (line 2), then the agent can drop the intention of continuing the search (line 6).
The library provides additional artifacts for working with dynamic hypermedia environments using W3C WebSub. Agents can monitor a resource using a WebSubThingArtifact stub, which extends the ThingArtifact to extract WebSub metadata from HTTP responses (i.e., the WebSub topic and hub IRI to subscribe to). Agents can then use this metadata to register the artifact stub with a NotificationServerArtifact: a CArtAgO artifact that can subscribe to WebSub topics and exposes a callback IRI for receiving notifications. When a new notification arrives, the server then routes it to the relevant artifact stub by invoking a linked operation (i.e., a CArtAgO operation meant for artifact-to-artifact communication). The artifact stub interprets the notification and updates its observable properties if needed (e.g., to expose a new value). Any agent focused on the artifact stub will then perceive the updates. Note that the WorkspaceThingArtifact is, in fact, a subclass of WebSubThingArtifact—and, for example, will update its observable properties whenever a new artifact or child workspace is created. Other mechanisms for monitoring resources besides WebSub can be implemented similarly.

### 7.4.3 A Hypermedia Search Engine for Autonomous Agents

Browsing hypermedia-based workspaces is a strategy that works for small settings but is inefficient in large hypermedia environments (in terms of running time, computational resources, network usage, etc.). To this end, we developed a prototypical hypermedia search engine that agents can use to perform approximate search queries in weak real time.<fnref n="30" /> The search engine has two main components: (i) a crawler for dynamic hypermedia environments and (ii) a semantic query engine based on CORESE [10], an open-source inference and query engine for Linked Data. The crawler accommodates dynamic environments that support W3C WebSub by subscribing to updates of previously crawled resources. This design avoids the need for constant re-crawling and reflects environmental changes in query results rather quickly. The query engine then exposes a SPARQL endpoint that agents can use for approximate search: if there is no exact answer for a query, CORESE can approximate its semantics, structure, or both (see [19] for more details). The search engine was initially developed in the context of the WoT to crawl and index W3C WoT TD documents, but we intend to generalize and consolidate the initial prototype to support hMAS more broadly.

<footnote n="30">³⁰ The initial implementation of the hypermedia search engine was published in [15].</footnote>
## 7.5 Demonstrator and Limitations

We present a demonstrator with two BDI agents in a distributed artifact-based hypermedia environment in Sect. 7.5.1. In Sect. 7.5.2, we use this demonstrator to illustrate the benefits and drawbacks of using hypermedia to distribute MAS by contrasting against a baseline implementation without hypermedia. The demonstrator is available on GitHub.31

### 7.5.1 Demonstrator Application

We implemented a producer/consumer scenario with two Jason agents in a distributed hypermedia-based workspace. The root workspace contains three child workspaces distributed across three Yggdrasil nodes: one for producing items, one for consuming items, and one for transferring items between the agents. Agent *alice* is situated in the *production* workspace and uses a *source* artifact to produce items (cf. Listing 7.4). Agent *bob* is situated in the *consumption* workspace and uses a *sink* artifact to consume items. To transfer the items between them, the agents can use a *buffer* artifact located in the third *shared* workspace— but are unaware of its location or the structure of the hypermedia environment.

Both agents in our demonstrator achieve their goals starting from their home workspace as the single entry point into the distributed environment: they use *WorkspaceThingArtifact* stubs to enter the hMAS by loading and joining their home workspaces (lines 1–8 in Listing 7.6). The *joinHypermediaWorkspace* operation exploits the *jacamo:JoinWorkspace* hypermedia control in Listing 7.3 (lines 10–18). As they enter their home workspaces, the agents discover the *source* and *sink* artifacts, respectively. In the initial state of the demonstrator, the *production* and *consumption* workspaces are not linked to the root workspace. We add them as child workspaces of the root workspace by updating their representations to include *hmas:isContainedIn* relations. Both agents are able to *perceive* this change and start exploring the root workspace (cf. Listing 7.6). The *shared* workspace was already contained in the root workspace, so once the agents find the *buffer* artifact, they can start producing, transferring, and consuming items.

This demonstrator shows that coupling in hMAS is minimal: agents start from a single entry IRI into the hMAS and can achieve their goals by browsing, perceiving, and acting on resources.

<footnote n="31">31 Demonstrator: https://github.com/andreiciortea/eumas-toolkit-demo/.</footnote>
## 7.5.2 Discussion and Limitations

We compare our approach against a baseline implementation without hypermedia.<fnref n="32" /> We maintain the scenario and distributed setting: agents *alice* and *bob* still use three HTTP services for producing, consuming, and transferring items. However, instead of using hypermedia-based workspaces and hypermedia controls, we integrate the services into our JaCaMo application as usual: the agents use CArtAgO artifacts programmed against the HTTP APIs of the three services. For example, to use the service provided by a *Source* artifact (cf. Listing 7.4), our baseline implementation hard-codes an HTTP POST request to a `/produce` endpoint on the Yggdrasil node hosting the service. We use Yggdrasil nodes to run the remote services in this baseline implementation, but this does not affect the generality of the discussion: we would achieve a similar deployment setup by re-implementing the remote artifacts on three JaCaMo-REST nodes [1] or simply as regular non-hypermedia HTTP services. Our objective with this comparison is to illustrate the benefits and drawbacks of using hypermedia to distribute MAS.

One apparent benefit of using hypermedia when contrasting the two implementations is *evolvability*: without hypermedia, each agent is coupled to two of the three services in our scenario. If a service API or the deployment context changes, the agent breaks. The classical alternative would be to use service directories that agents could query to obtain updated descriptions of their services [56]. Our hypermedia agents, however, discover service descriptions *in context* as part of their regular interaction flow—and can *perceive* relevant changes as they occur (e.g., new metadata, new action possibilities). Therefore, instead of querying an out-of-band service directory for an updated description, the agents are *situated* in the hypermedia environment and can react to changes.

Besides evolvability, the use of hypermedia promotes *openness*: the hypermedia environment enables agents to freely navigate across nodes in their deployment context, and adding a new node to the system is as easy as creating a hyperlink to make it discoverable. Agents can enter and leave the hMAS freely by joining or quitting a workspace, and their presence in any given workspace is reflected by a representation of their body artifact. To enter the hMAS, the agent only needs an entry IRI and the set of ontologies capturing the environment model. The agent can then use the hypermedia environment to discover and interact with the rest of the hMAS, or it can even shape the hypermedia environment to better fit its needs. Without hyperlinks or the ability to leverage abstraction support from the environment, the non-hypermedia agents in our baseline implementation are limited to using the services they were programmed against.

Using hypermedia, however, increases the complexity of agent logic. Much of this added complexity can be mitigated with middleware (cf. Sect. 7.4.2); still, as visible in our baseline implementation, the classical approach of hard-coding

<footnote n="32">³² See demonstrator: https://github.com/andreiciortea/eumas-toolkit-demo/.</footnote>
assumptions about the environment into agents simplifies agent programming significantly.<fnref n="33" /> Hence, if the loose coupling provided through hypermedia is not required by a given use case, a more tightly coupled but simpler agent program would be preferable.

## 7.6 The Road Ahead

This chapter presents the Yggdrasil model and framework for designing and programming hMAS. Yggdrasil solves the problem of *weaving* MAS in the hypermedia fabric of the Web. The specific focus of our approach is on the environment as a first-class abstraction. A distinguishing feature of an environment developed with Yggdrasil is that it provides agents with a knowledge-level abstraction of their MAS that hides the lower-level details of their deployment context behind semantic models and hypermedia controls. The agents then interact with the rest of the MAS through the hypermedia environment using a *uniform interface* that allows them to browse, selectively perceive, and act on any resource in the hMAS—globally and independently of context. This design rationale minimizes coupling in the system and promotes *openness* and *evolvability*. Our hypermedia-based environment model adds structure to an open system and bridges the conceptual gap between agents and their deployment context. The Yggdrasil framework then enforces key design constraints to *facilitate distribution across the Web*—for example, by properly identifying non-information resources and managing specific links to ensure the open environment is navigable. To support our approach and research on hMAS more broadly, we provide a set of open-source technologies that can be used for rapid prototyping.

In what follows, we first position Yggdrasil in the current landscape of Generative AI and then sketch a research roadmap for the next 10 years.

### 7.6.1 Interweaving AOSE and Generative AI

The impressive wave of recent advances in generative AI has brought new capabilities and renewed interest in autonomous agents. Notably, a plethora of frameworks are now available to build applications based on language models (e.g., see [65]), and benchmarks such as WebShop [66] promote research on language agents in Web environments. Of particular interest to our research is the use of *tools* [44] by language agents—especially when the tools are discovered at run time and used via API calls [48, 54]. Research efforts in this area are still preliminary and tend to focus

<footnote n="33">³³ See the source code of the producer agent: https://github.com/andreiciortea/eumas-toolkit-demo/blob/main/agents/src/main/jason/producer.asl.</footnote>
on specific tools (with the notable exception of [48]), but these developments hold great promise for designing autonomous agents that are not constrained by manually engineered models—as is the case for the agents in our demonstrator and, more generally, for agents programmed against semantic API descriptions. However, such language agents would still have to be situated in an environment that allows them to discover and use the tools they need for their activities.

In this context, Yggdrasil provides a conceptual model for tool use in open environments populated by heterogeneous agents—including people, BDI agents, and language agents. This conceptual model has a solid theoretical foundation that is based on the principles of AOSE and grounded in activity theory [49], and our hypermedia-based design brings the flexibility required to accommodate heterogeneous agents via uniform interfaces. An immediate next step is to evaluate how well language agents can already use Yggdrasil to browse, perceive, and act in such hypermedia environments—and what extensions are still needed, if any. For example, interfaces using protocols such as the Model Context Protocol (MCP) [2] could further accommodate language agents. The Yggdrasil model and framework could then provide the means to seamlessly interweave classical AOSE approaches with those based on generative AI—and could take a significant step in bridging the part of the Web designed for machines with the one designed for humans, and in bridging social semantics and formal semantics on the Web [29].

### 7.6.2 Directions for Future Research

This chapter summarizes our efforts over the past years in building open-source software to support research on hMAS—but it only scrapes the surface of research opportunities. In the following, we outline a few directions for future work, some more immediate and others less so.

In our current implementation, Yggdrasil exposes artifact descriptions that do not reflect the internal state of artifacts. For example, if a fan is already on, exposing an action possibility to turn on the fan would be of no use. The same observation applies to virtual hypermedia artifacts: in our demonstrator, the *enqueue* and *poll* operations of the *buffer* artifact can only be used if the state of its internal bounded buffer allows it—a constraint that is also apparent from the use of guards on these operations.<fnref n="34" /> An immediate extension that would bring the framework implementation closer to our conceptual model is to expose only action possibilities that can *actually* be exploited by agents. To further generalize this issue, over the past years, we developed a more in-depth understanding of affordances in hMAS and the role of *signifiers* in advertising action possibilities to agents [59, 60]. One mechanism we are developing as a longer-term endeavor is a *signifier exposure*

<footnote n="34">³⁴ See source code: https://github.com/andreiciortea/eumas-toolkit-demo/blob/main/environment/src/main/java/org/hyperagents/demo/BoundedBuffer.java.</footnote>
*mechanism* [42] that would allow agents to perceive signifiers depending on whether or not they are contextually relevant at run time. This mechanism thus aims to increase interaction efficiency in hypermedia environments by hiding action possibilities that are irrelevant to agents in their current situation. It also aims to enable the personalization of hypermedia environments to accommodate heterogeneous agents—for example, by exposing signifiers specific to language agents. Note that the filtered signifier exposure does not amount to censorship of action possibilities: it is a service provided to agents, and agents may choose at any time not to use this service.

Another research direction is to design an interface for language agents that are *situated* and *embodied* in hypermedia environments. Our preliminary experience suggests that simply verbalizing the RDF representations of W3C WoT TD documents or relying on OpenAPI descriptions is insufficient. In other experiments, we showed that the choice of language used to integrate generative AI and knowledge graphs in a task can have a significant impact on performance [51]. An interface based on controlled natural language might be more sensible for embodied language agents (e.g., see also [43]). Furthermore, hypermedia environments can extend seamlessly to the physical world, and such an interface would enable the creation of benchmarks that support applications of language models to robotics (e.g., see [37, 61]) and cyber-physical systems.

In Sect. 7.4.2, we presented naive crawling strategies that allow BDI agents to cope with the openness of hypermedia environments: given an entry point into a hypermedia-based workspace, agents can use these strategies to ground the abstract plans they are equipped with into action possibilities discovered in the environment at run time. Further research is needed to identify patterns and best practices for autonomous browsing. Regardless if such strategies are pre-programmed or synthesized at run time, they are indispensable if agents are to benefit from the flexibility that comes with open hypermedia environments—and understanding the involved trade-offs is essential.

Finally, a long-term challenge we consider worth pursuing is what we call the *arrive-and-operate problem*: given a single entry IRI in a distributed hypermedia environment, an agent should be able to use its prior knowledge and experience to achieve its goals by browsing hypermedia and exploiting affordances discovered at run time. Such behavior can be achieved easily in simple hypermedia environments, like the one in our demonstrator, but it quickly becomes intractable in large, heterogeneous, and unknown environments: the complexity of a hypermedia environment can rival or even surpass that of the physical world. The difficulty of the *arrive-and-operate problem* thus depends on the nature of the environment—and we hypothesize there are use cases motivating further investigation of the full spectrum of autonomous agents available across the AOSE and generative AI communities.
**Acknowledgments** This research received funding from the Swiss National Science Foundation under grant No. 189474 (HyperAgents). This work has also been supported by the French government, through the 3IA Cote d'Azur reference number ANR-23-IACL-0001 managed by the National Research Agency (ANR), France 2030. The development of our tooling around Hypermedia MAS started back in 2018. Since then, several students have contributed to parts of the technology presented in this chapter. We thank Simon Bienz for his prototypical implementation of the hypermedia search engine and Philip Junker for his contributions to Yggdrasil. We also thank everyone who has contributed to these efforts via GitHub.

## References

1. Amaral, C.J., Hübner, J.F., Kampik, T.: Towards jacamo-rest: A resource-oriented abstraction for managing multi-agent systems. In: Vaz Alves, G., Guiménez Lug, G., Pinz Borgeso, A., Pantoja, C.E. (eds.) Proceedings of the 14th Workshop-School on Agents, Environments, and Applications, pp. 140–151 (2020)

2. Anthropic: Model context protocol. https://modelcontextprotocol.io/specification/2025-03-26 (Mar 26 2025), 2025-03-26 version

3. Berners-Lee, T., Hendler, J., Lassila, O.: The semantic web. Sci. Amer. **284**(5), 34–43 (2001). https://doi.org/10.1038/scientificamerican0501-34

4. Bizer, C., Heath, T., Berners-Lee, T.: Linked Data - The Story So Far, pp. 115–143, 1st edn. Association for Computing Machinery, New York, NY, USA (2023). https://doi.org/10.1145/3591366.3591378

5. Boissier, O., Bordini, R., Hübner, J.F., Ricci, A.: Multi-Agent Oriented Programming: Programming Multi-Agent Systems Using JaCaMo. The MIT Press (2020)

6. Boissier, O., Ciortea, A., Harth, A., Ricci, A., Vachtsevanou, D.: Agents on the web (Dagstuhl seminar 23081). Dagstuhl Reports **13**(2), 71–162 (2023). https://doi.org/10.4230/DagRep.13.2.71

7. Calbimonte, J.P., Calvaresi, D., Schumacher, M.: Multi-agent interactions on the web through linked data notifications. In: Belardinelli, F., Argente, E. (eds.) Multi-Agent Systems and Agreement Technologies. pp. 44–53. Springer International Publishing, Cham (2018)

8. Calbimonte, J.P., Ciortea, A., Kampik, T., Mayer, S., Payne, T.R., Tamma, V., Zimmermann, A.: Autonomy in the age of knowledge graphs: Vision and challenges. Trans. Graph Data Knowl. **1**(1), 13:1–13:22 (2023). https://doi.org/10.4230/TGDK.1.1.13. https://drops.dagstuhl.de/entities/document/10.4230/TGDK.1.1.13

9. Capadisli, S., Guy, A.: Linked Data Notifications. W3C Recommendation, W3C (May 2 2017). https://www.w3.org/TR/ldn/

10. Cérès, R., Corby, O., Demairy, E., Gandon, F.: Corese (Jul 2023). https://doi.org/10.5281/zenodo.10376241. https://hal.science/hal-04170333

11. Charpenay, V., Käfer, T., Harth, A.: A unifying framework for agency in hypermedia environments. In: International Workshop on Engineering Multi-Agent Systems, pp. 42–61. Springer (2021)

12. Charpenay, V., Lefrançois, M., Poveda-Villalón, M., Käbisch, S.: Web of Things (WoT) Thing Description (TD) Ontology. Editor's Draft, W3C (2022)

13. Ciortea, A., Boissier, O., Ricci, A.: Engineering World-Wide Multi-Agent Systems with Hypermedia. In: Weyns, D., Mascardi, V., Ricci, A. (eds.) Engineering Multi-Agent Systems, pp. 285–301. Springer International Publishing, Cham (2019)

14. Ciortea, A., Gandon, F., Lefrançois, M., Vachtsevanou, D., Leturc, C., Boissier, O., Nardin, L.G., Mayer, S., Charpenay, V., Zimmermann, A.: Hypermedia MAS Core Ontology. Tech. rep., HyperAgents (2024). https://purl.org/hmas/core
15. Ciortea, A., Mayer, S., Bienz, S., Gandon, F., Corby, O.: Autonomous search in a social and ubiquitous web. Personal Ubiquitous Comput. 28(1), 259–272 (2020). https://doi.org/10.1007/s00779-020-01415-1

16. Ciortea, A., Mayer, S., Gandon, F., Boissier, O., Ricci, A., Zimmermann, A.: A Decade in Hindsight: The Missing Bridge Between Multi-Agent Systems and the World Wide Web. In: Proceedings of the 18th International Conference on Autonomous Agents and MultiAgent Systems. p. 1659–1663. AAMAS ’19, International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC (2019)

17. Ciortea, A., Zimmermann, A., Boissier, O., Florea, A.M.: Hypermedia-Driven Socio-Technical Networks for Goal-Driven Discovery in the Web of Things. In: Proceedings of the Seventh International Workshop on the Web of Things, WoT ’16, pp. 25–30. Association for Computing Machinery, New York, NY, USA (2016). https://doi.org/10.1145/3017995.3018001

18. Collier, R.W., O'Neill, E., Lillis, D., O'Hare, G.: Mams: Multi-agent microservices. In: Companion proceedings of the 2019 World Wide Web Conference, pp. 655–662 (2019)

19. Corby, O., Dieng-Kuntz, R., Gandon, F., Faron-Zucker, C.: Searching the semantic web: approximate query processing based on ontologies. IEEE Intell. Syst. 21(1), 20–27 (2006). https://doi.org/10.1109/MIS.2006.16

20. Demazeau, Y.: From interactions to collective behaviour in agent-based systems. In: Proceedings of the European Conference on Cognitive Science, pp. 117–132 (1995)

21. Dikenelli, O., Alatlı, O., Erdur, R.C.: Where are all the semantic web agents: Establishing links between agent and linked data web through environment abstraction. In: Weyns, D., Michel, F. (eds.) Agent Environments for Multi-Agent Systems IV, pp. 41–51. Springer International Publishing, Cham (2015)

22. Dikenelli, O.: Seagent mas platform development environment. In: Proceedings of the 7th International Joint Conference on Autonomous Agents and Multiagent Systems: Demo Papers, AAMAS ’08, pp. 1671–1672. International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC (2008). http://dl.acm.org/citation.cfm?id=1402744.1402758

23. Exposito, J., Ametller, J., Robles, S.: Configuring the JADE HTTP MTP. http://jade.tilab.com/documentation/tutorials-guides/configuring-the-jade-http-mtp/ (2010), accessed: 20.04.2018

24. Fielding, R.T., Taylor, R.N.: Principled design of the modern web architecture. ACM Trans. Int. Technol. 2(2), 115–150 (2002). http://doi.acm.org/10.1145/514183.514185

25. Foundation for Intelligent Physical Agents: FIPA Agent Message Transport Protocol for HTTP Specification (2002). http://www.fipa.org/specs/fipa00084/SC00084F.html. Document number: SC00084F

26. Gandon, F.: A Survey of the First 20 Years of Research on Semantic Web and Linked Data. Revue des Sciences et Technologies de l'Information - Série ISI : Ingénierie des Systèmes d'Information (Dec 2018). https://doi.org/10.3166/ISI.23.3-4.11-56. https://inria.hal.science/hal-01935898

27. Gandon, F.: Merry hMAS and Happy New Web: A Wish for Standardizing an AI-Friendly Web Architecture for Hypermedia Multi-Agent Systems. In: Dagstuhl-Seminar 21072 : Autonomous Agents on the Web, p. 3. Dagstuhl Schloss, Dagstuhl, Germany (Feb 2021). https://inria.hal.science/hal-03960471

28. Gandon, F.: Finding the Critical MAS(S): Resources and Representations Needed for Weaving a Web that Hosts Linked Multi-Agent Systems. In: Dagstuhl Seminar 23081 : Agents on the Web. Dagstuhl Schloss, Dagstuhl, Germany (Feb 2023). https://inria.hal.science/hal-03989703

29. Gandon, F., Buffa, M., Cabrio, E., Corby, O., Faron Zucker, C., Giboin, A., Le Thanh, N., Mirbel, I., Sander, P., Tettamanzi, A.G.B., Villata, S.: Challenges in Bridging Social Semantics and Formal Semantics on the Web. In: Hammoudi, S., Cordeiro, J., Maciaszek, L.A., Filipe, J. (eds.) Lecture Notes in Business Information Processing. Lecture Notes in Business Information Processing, vol. 190, pp. 3–15. Springer, Angers, France (Jul 2013). https://inria.hal.science/hal-01059273

30. Genestoux, J., Parecki, A.: WebSub. W3C Recommendation, W3C (Jan 23 2018). https://www.w3.org/TR/websub/
31. Gibbins, N., Harris, S., Shadbolt, N.: Agent-based semantic web services. Web Semant. Sci. Serv. Agents World Wide Web 1(2), 141–154 (2004)

32. Gouaïch, A., Bergeret, M.: Rest-a: An agent virtual machine based on rest framework. In: Demazeau, Y., Dignum, F., Corchado, J.M., Pérez, J.B. (eds.) Advances in Practical Applications of Agents and Multiagent Systems, pp. 103–112. Springer, Berlin, Heidelberg (2010)

33. Gregori, M.E., Cámara, J.P., Bada, G.A.: A jabber-based multi-agent system platform. In: Proceedings of the Fifth International Joint Conference on Autonomous Agents and Multiagent Systems, AAMAS ’06, pp. 1282–1284. ACM, New York, NY, USA (2006). http://doi.acm.org/10.1145/1160633.1160866

34. Guinard, D., Trifa, V., Wilde, E.: A resource oriented architecture for the web of things. In: 2010 Internet of Things (IOT), pp. 1–8 (Nov 2010). https://doi.org/10.1109/IOT.2010.5678452

35. Hogan, A., Blomqvist, E., Cochez, M., D'amato, C., Melo, G.D., Gutierrez, C., Kirrane, S., Gayo, J.E.L., Navigli, R., Neumaier, S., Ngomo, A.C.N., Polleres, A., Rashid, S.M., Rula, A., Schmelzeisen, L., Sequeda, J., Staab, S., Zimmermann, A.: Knowledge graphs. ACM Comput. Surv. 54(4), (2021). https://doi.org/10.1145/3447772

36. Huhns, M.N.: Agents as web services. IEEE Internet Comput. 6(4), 93 (2002)

37. Ichter, b., Brohan, A., Chebotar, Y., Finn, C., Hausman, K., Herzog, A., Ho, D., Ibarz, J., Irpan, A., Jang, E., Julian, R., Kalashnikov, D., Levine, S., Lu, Y., Parada, C., Rao, K., Sermanet, P., Toshev, A.T., Vanhoucke, V., Xia, F., Xiao, T., Xu, P., Yan, M., Brown, N., Ahn, M., Cortes, O., Sievers, N., Tan, C., Xu, S., Reyes, D., Rettinghouse, J., Quiambao, J., Pastor, P., Luu, L., Lee, K.H., Kuang, Y., Jesmonth, S., Joshi, N.J., Jeffrey, K., Ruano, R.J., Hsu, J., Gopalakrishnan, K., David, B., Zeng, A., Fu, C.K.: Do as i can, not as i say: Grounding language in robotic affordances. In: Liu, K., Kulic, D., Ichnowski, J. (eds.) Proceedings of The 6th Conference on Robot Learning. Proceedings of Machine Learning Research, vol. 205, pp. 287–318. PMLR (14–18 Dec 2023). https://proceedings.mlr.press/v205/ichter23a.html

38. Jacobs, I., Walsh, N.: Architecture of the World Wide Web. W3C Recommendation, W3C (Dec 15 2004). http://www.w3.org/TR/2004/REC-webarch-20041215/

39. Kaebisch, S., Kamiya, T.: Web of Things Thing Description 1.1. W3C Recommendation, W3C (Dec 05 2023). https://www.w3.org/TR/wot-thing-description11/

40. Khare, R., Taylor, R.N.: Extending the representational state transfer (rest) architectural style for decentralized systems. In: Proceedings. 26th International Conference on Software Engineering, pp. 428–437. IEEE (2004)

41. Lagally, M., Matsukura, R., McCool, M., Toumura, K.: Web of Things (WoT) Architecture 1.1. W3C Recommendation, W3C (Dec 05 2023). https://www.w3.org/TR/2023/REC-wot-architecture11-20231205/

42. Lemée, J., Vachtsevanou, D., Mayer, S., Ciortea, A.: Signifiers for conveying and exploiting affordances: from human-computer interaction to multi-agent systems. Ann. Math. Artif. Intell., 1–21 (2024)

43. Li, K., Yu, B., Zheng, Q., Zhan, Y., Zhang, Y., Zhang, T., Yang, Y., Chen, Y., Sun, L., Cao, Q., Shen, L., Li, L., Tao, D., He, X.: MuEP: a multimodal benchmark for embodied planning with foundation models. In: Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI ’24 (2024). https://doi.org/10.24963/ijcai.2024/15

44. Mialon, G., Dessi, R., Lomeli, M., Nalmpantis, C., Pasunuru, R., Raileanu, R., Roziere, B., Schick, T., Dwivedi-Yu, J., Celikyilmaz, A., Grave, E., LeCun, Y., Scialom, T.: Augmented language models: a survey. Trans. Mach. Learn. Res. (2023). https://openreview.net/forum?id=jh7wH2AzKK. Survey Certification

45. Mitrović, D., Ivanović, M., Budimac, Z., Vidaković, M.: Radigost: Interoperable web-based multi-agent platform. J. Syst. Software 90, 167–178 (2014). https://doi.org/10.1016/j.jss.2013.12.029. http://www.sciencedirect.com/science/article/pii/S0164121214000028

46. O'Neill, E., Lillis, D., O'Hare, G.M., Collier, R.W.: Delivering multi-agent microservices using CArtAgO. In: Engineering Multi-Agent Systems: 8th International Workshop, EMAS 2020, Auckland, New Zealand, May 8–9, 2020, Revised Selected Papers 8, pp. 1–20. Springer (2020)
47. Page, K.R., De Roure, D.C., Martinez, K.: Rest and linked data: a match made for domain driven development? In: Proceedings of the Second International Workshop on RESTful Design, WS-REST ’11, pp. 22–25. ACM, New York, NY, USA (2011). https://doi.org/10.1145/1967428.1967435

48. Patil, S.G., Zhang, T., Wang, X., Gonzalez, J.E.: Gorilla: Large language model connected with massive apis. In: Globerson, A., Mackey, L., Belgrave, D., Fan, A., Paquet, U., Tomczak, J., Zhang, C. (eds.) Advances in Neural Information Processing Systems, vol. 37, pp. 12654–12656. Curran Associates, Inc. (2024). https://proceedings.neurips.cc/paper_files/paper/2024/file/e4c61f578ff07830f5c37378dd3ecb0d-Paper-Conference.pdf

49. Ricci, A., Piunti, M., Viroli, M.: Environment programming in multi-agent systems: an artifact-
based perspective. Auton. Agents Multi Agent Syst. **23**, 158–192 (2011)

50. Ricci, A., Piunti, M., Viroli, M., Omicini, A.: Environment Programming in CArtAgO. Multi-agent Programming: Languages, Tools and Applications, pp. 259–288 (2009)

51. Ringwald, C., Gandon, F., Faron, C., Michel, F., Akl, H.A.: 12 shades of RDF: Impact of Syntaxes on Data Extraction with Language Models. In: ESWC 2024 Extended Semantic Web Conference, Hersonissos, Greece (May 2024). https://hal.science/hal-04581124. Accepted at ESWC 2024

52. Sambra, A.V., Mansour, E., Hawke, S., Zereba, M., Greco, N., Ghanem, A., Zagidulin, D., Aboulnaga, A., Berners-Lee, T.: Solid: a platform for decentralized social applications based on linked data. Tech. rep. MIT CSAIL & Qatar Computing Research Institute, Tech. Rep. (2016)

53. Sauermann, L., Cyganiak, R.: Cool URIs for the Semantic Web. W3C Interest Group Note, W3C (2008). http://www.w3.org/TR/cooluris/

54. Schick, T., Dwivedi-Yu, J., Dessi, R., Raileanu, R., Lomeli, M., Hambro, E., Zettlemoyer, L., Cancedda, N., Scialom, T.: Toolformer: Language models can teach themselves to use tools. In: Oh, A., Naumann, T., Globerson, A., Saenko, K., Hardt, M., Levine, S. (eds.) Advances in Neural Information Processing Systems, vol. 36, pp. 68539–68551. Curran Associates, Inc. (2023). https://proceedings.neurips.cc/paper_files/paper/2023/file/d842425e4bf79ba039352da0f658a906-Paper-Conference.pdf

55. Shelby, Z., Hartke, K., Bormann, C.: RFC 7252: The constrained application protocol (CoAP) (2014)

56. Singh, M.P., Huhns, M.N.: Service-Oriented Computing: Semantics, Processes, Agents. Wiley (2006). https://doi.org/10.1002/0470091509

57. Speicher, S., Arwe, J., Malhotra, A.: Linked Data Platform 1.0. W3C Recommendation, W3C (Feb 26 2015). http://www.w3.org/TR/ldp/

58. Tummolini, L., Castelfranchi, C., Ricci, A., Viroli, M., Omicini, A.: "Exhibitionists" and "Voyeurs" do it better: A shared environment for flexible coordination with tacit messages. In: Environments for Multi-Agent Systems: First International Workshop, E4MAS 2004, pp. 215–231, New York, NY, July 19, 2004. Revised Selected Papers 1. Springer (2005)

59. Vachtsevanou, D., Ciortea, A., Mayer, S., Lemée, J.: Signifiers as a first-class abstraction in hypermedia multi-agent systems. In: Proceedings of the 2023 International Conference on Autonomous Agents and Multiagent Systems, AAMAS ’23, pp. 1200–1208. International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC (2023)

60. Vachtsevanou, D., de Lima, B., Ciortea, A., Hübner, J.F., Mayer, S., Lemée, J.: Enabling BDI agents to reason on a dynamic action repertoire in hypermedia environments. In: Proceedings of the 23rd International Conference on Autonomous Agents and Multiagent Systems, AAMAS ’23, pp. 1856–1864. International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC (2024)

61. Vemprala, S.H., Bonatti, R., Bucker, A., Kapoor, A.: ChatGPT for robotics: Design principles and model abilities. IEEE Access **12**, 55682–55696 (2024). https://doi.org/10.1109/ACCESS.2024.3387941

62. Weyns, D., Omicini, A., Odell, J.: Environment as a first class abstraction in multiagent systems. Auton. Agents Multi Agent Syst. **14**(1), 5–30 (2007)
63. Weyns, D., Steegmans, E., Holvoet, T.: Towards active perception in situated multi-agent systems. Appl. Artif. Intell. 18(9-10), 867–883 (2004)

64. Wilde, E.: Putting Things to Rest. School of Information, UC Berkeley (2007)

65. Yang, H., Yue, S., He, Y.: Auto-GPT for online decision making: Benchmarks and additional opinions (2023). https://arxiv.org/abs/2306.02224

66. Yao, S., Chen, H., Yang, J., Narasimhan, K.: WebShop: Towards scalable real-world web interaction with grounded language agents. In: Koyejo, S., Mohamed, S., Agarwal, A., Belgrave, D., Cho, K., Oh, A. (eds.) Advances in Neural Information Processing Systems, vol. 35, pp. 20744–20757. Curran Associates, Inc. (2022). https://proceedings.neurips.cc/paper_files/paper/2022/file/82ad13ec01f9fe44c01cb91814fd7b8c-Paper-Conference.pdf

67. Zimmermann, A., Ciortea, A., Faron, C., O'Neill, E., Poveda-Villalón, M.: Pody: A solid-based approach to embody agents in web-based multi-agent-systems. In: Ciortea, A., Dastani, M., Luo, J. (eds.) Engineering Multi-Agent Systems, pp. 220–229. Springer Nature Switzerland, Cham (2023)