On 17 November 2026, Visions and Prometheus-X hosted a webinar titled “Trust, interoperability and collaboration: the next generation of data spaces”. 121 participants took part: data space managers, architects, developers and open source contributors.
Two questions shaped the session: how do we automate trust, and how do we collaborate to build this common layer? Here is what was presented, what already works, and how you can join the work.

The starting point: trust unlocks the most sensitive data

In every sector, organisations are looking for precise answers based on private data held by others, often by their competitors. A venue wants to know whether its occupancy is normal. An education stakeholder wants to know which learning tools work on a territory, and a health stakeholder what the real effects of a drug are over several years. These questions span education (xapi4research), skills (DS4Skills), culture (Technè), energy and buildings (Location Data Space) and health (Health Data Trust).

The same chain in every data space

The same chain repeats everywhere. At each provider, raw data never leaves: it is processed locally, anonymised and mapped to a common model. In the common pool, only aggregated results circulate, under size thresholds and release checks. On the usage side, we know who uses the data, for what purpose, and what value goes back to each contributor. The building blocks are always the same; only the values change.

So the real question is about rules. Is the data really anonymised? What guarantees that a competitor cannot access my confidential data? Who checks the roles, and how is my share of the value calculated? These rules must be defined, enforced and verified, largely automatically and always in a checkable way.

Six principles for shared trust

Six principles frame the approach. Rules are defined together, by the data spaces. They are automated and verified on every exchange. No technology is imposed: each data space keeps its own stack. Only the minimum is mandatory; everything else stays local. And there is no ready-made solution: we need to combine what exists and agree.

Two commons to scale

To scale, two kinds of commons are needed. The first is a governance commons, the Data Space Interoperability Framework (DSIF), where data spaces set the minimum rules to federate, whatever their technology. The second is a software commons, Prometheus-X, where those who wish to do so pool, in open source, the components that verify and enforce these rules. VisionsTrust, like EDC, FIWARE or Simpl, is just one possible implementation among others.

The common thread: xapi4research, trustworthy AI in education

All the demos were built on the same use case. The French Ministry of Education wants to know which digital tools, AI and learner profiling actually work, so it can better fund, buy and certify them.
The question is concrete: for each learner profile, which personalisation is effective? Researchers need learning traces in xAPI format: attempts, hints, time spent, returns to a concept. The first scope covers mathematics in the first year of secondary school.

Why several EdTech providers? Computed on a single tool, a profile describes the users of that tool. Computed across several, it describes pupils, and makes it possible to separate the effect of a practice from the effect of a product. But this data is doubly sensitive: it is personal data about pupils, subject to the GDPR, and competitive data between EdTech providers. So trust has to be built. 

A common rulebook to build trust

Olivier Dion (Onecub, Prometheus-X) started from the point of view of an EdTech provider asked to share its traces with competitors and researchers. Before sharing, it asks five questions. Who will access its data, and for what use? Will it really be anonymised? Can a competitor isolate its results? Who checks, and with what evidence? Can it leave and take its data back? A rulebook answers these questions in advance.

One rule, four levels

Take the fear of being identified by a competitor. The answer becomes a concrete rule, written into the EdTech provider’s contract with the commons and checked before every release. No aggregate covers fewer than 25 pupils, each aggregate includes at least 3 EdTech providers, and none accounts for more than 50% of the total.

This rule does not stand alone. It sits on a stack of four levels, where each level can tighten a value but never loosen it.

Level L0, shared by all data spaces, sets the rule without fixing its value. Every exchange is contracted, authorised, traced and verified, and the right to exit is guaranteed. At level L1, DS4Skills sets a floor of 10 people, declares roles and validates identities at onboarding. At level L2, the xapi4research use case raises the threshold to 20 pupils. It requires at least 3 EdTech providers, none above 50% of the total, and restricts results to public research. Finally, at level L3, the contract between the EdTech provider and the commons sets the value at 25 pupils for that provider’s data.

Verification is carried out by the release gate of the Edge Node Server, and the evidence is the log of that check. The more general a rule, the more it pays to pool it.

The L0, a common base for all data spaces

That is the purpose of the L0. To interoperate and trust each other, data spaces need to agree on several points:

  • how rules are verified and the level of evidence accepted;
  • onboarding criteria;
  • offer and contract models;
  • value exchange between data spaces;
    the governance of the L0 itself.

The DSSC rule register (version 0.1, 23 October 2026) already contains 36 rules and 4 core roles, including 9 agreed rules. But it stops where a federation begins. It does not say how the shared L0 evolves, or which evidence data spaces accept from one another.

Towards the first DSIF federation

DSIF builds on this foundation with the data spaces ready to commit. Eight data spaces form the starting group: DS4Skills, CEADS, DS4SSCC, DEPLOYTOUR, Legal Data Space, Health Data Trust, Technè and Location Data Space. They cover different sectors and stacks, both centralised and decentralised, and already work together on projects. The goal is to vote on a binding L0 V1 and launch the first DSIF federation on 19 April 2027. Members will implement this L0, and checks carried out by one member will be recognised by the others.

Machine-readable rules: the rule bank

Félix Bole (Visions, Prometheus-X) described the gap between today’s situation and what data spaces need. Today, a provider has to trust a PDF, and checks are manual when they exist at all. No evidence comes with exchanges, and every data space rewrites the same rules. What is needed instead is rules a machine can read, the right building block triggered at the right time, evidence produced at every exchange, and a single translation shared by all.

Every rule becomes a record

In the rule bank, each rule becomes a structured record that describes:

  • what it says: statement, strength, obligation or prohibition, roles involved;
  • where it sits: level, parent rule, parameters and who sets them;
  • how it is enforced: building block, machine-readable expression;
  • how it is proven: control, evidence, who may see it.

This format follows the 15 fields of the DSSC rule record, extended by Prometheus-X with structured parameters, typed expressions and versioning.

Each level does not copy the rule: it points to it and sets or tightens its values. At contract level, these values are linked to their source rules, and the Edge Node Server reads them directly from the contract. Félix showed live, in VisionsTrust, the contract signed between the EdTech provider and the commons: the rule in text, then its technical version, read by the connector at every exchange.

An architecture that works with any stack

The architecture relies on a rule bank shared by all data spaces and one rulebook per data space. It builds on standard formats: ODRL for usage, SHACL for metadata, Verifiable Credentials for participants. It works whatever the stack: Prometheus-X, EDC, FIWARE, Simpl, Solid or a proprietary stack. Two data spaces on different stacks can therefore read and apply the same rules as long as they share a format and identifiers. 25 L0 rules have already been translated. The format is being discussed with DS4Skills, Health Data Trust, Legal Data Space, Technè and Location Data Space. The rule bank code is available on GitHub.

The connector enforces the rules

Nicolas Gretten (Visions) presented the target in five steps. The connector reads the contract, then identifies the checks and building blocks that apply. It triggers or verifies the component responsible for enforcing the rule, and retrieves a signed, logged proof. It then transfers the data, or refuses the exchange. In xapi4research, the contract carries the 25-pupil rule: without proof from the Edge Node Server, no exchange takes place.

What already works

Today, a Prometheus-X exchange already verifies the signed contract and its ODRL policies on both sides, at the provider and at the consumer. Nicolas illustrated this with a real service chain. Tutoring session traces from Tutorlink go through LearnHarbor’s Edge Node Server, then feed the learning analytics AI service of xAPI for Research. Each participant can run its connector as a managed service or self-hosted.

The connector already includes a Policy Enforcement Point (PEP), which reads and validates the rules in a contract to continue or stop an exchange. It also includes the Data Value Chain Tracker and Data Veracity Assurance. Since version 1.12, the separation between control plane and data plane makes it possible to plug in any enforcement service. What is still missing is the link to external proofs: verifying rules from a rulebook and relying on any enforcement component. The connector code is available on GitHub.

Edge Node Server: the end-to-end demo

László Gönczy (BME, Prometheus-X) reminded the audience that in sensitive cases, part of the processing must run where the data lives. Three types of L0 rules then apply to every data space: local processing, anonymisation before release, and a release threshold. This threshold only allows aggregates above a minimum group size.

In xapi4research, this means converting traces to xAPI and mapping them to the shared referential. Identifiers are then removed, timestamps coarsened and free text excluded, before the group size is checked ahead of any release.

Inside the Edge Node Server

The Edge Node Server brings these functions together around the connector, which acts as the entry point and propagates rules to the node. Raw data is never stored there, and only validated results leave the node. Other building blocks complete it: Edge Translator, Data Value Chain Tracker, decentralised AI through federated learning, and the Learning Record Converter. This work is carried by Prometheus-X, Visions, BME, Inokufu, Headai, IMC, Loria, AffectLog and Rejustify, with Outscale and Orange Business on the cloud side.

Above and below the threshold

The demo followed the whole chain, from Tutorlink’s traces to the data commons. Above the threshold, data is prepared on the Edge Node Server and the check passes. The anonymised aggregate is then sent with its proof to xAPI for Research. Below the threshold, the check fails: nothing leaves the node, and the refusal is logged.

The xapi4research chain now runs end to end. The release gate is driven by the contract values, and both refusals and releases are logged as evidence. This is still a first proof of concept with fixed logic. Next extensions cover additional transformation steps, a configuration workflow for node operation, and more advanced use of edge computing to scale.

Interoperability across data spaces and stacks

Félix Bole, Benoit Alessandroni (StartinBlox) and Juanjo Hierro (Seamware) presented the DSIF approach. Each ecosystem runs its own stack. An offer published in one data space is invisible from another, contracts do not cross stacks, and consent and identity do not follow the data. Each new pair of ecosystems requires a custom integration.

DSIF replaces no implementation (Prometheus-X, EDC, FIWARE, Simpl, Solid). It defines the minimal bridges between them to discover, contract, carry consent and recognise identities. These bridges build on DCAT, ISO/IEC 27560 and OID4VC.

One use case illustrates this next frontier. xapi4research wants to combine learning traces from DS4Skills (Prometheus-X stack) with the consumption of educational and news media from the TEMS media data space (EDC stack). The question: does media use help learning?

Discovering offers from another data space

For discovery, offers stay where they are, but become visible from any federated catalogue. This relies on sector registration and search authorities. The StartinBlox demo showed it in four steps. AFP publishes an offer in TEMS, on EDC, and its self-description is registered in the sector directory. Tralalère then finds this offer from its DS4Skills catalogue, with its conditions. Finally, it contracts through its own stack. TEMS, DS4Skills and FIWARE are connected today, and Simpl is next.

Contracting across stacks

For contracts, each stack contracts its own way, and a buyer on one stack cannot sign on another. DSIF therefore proposes a neutral integration model and a common action model: retrieve an offering, request an acquisition, record, track, retrieve and terminate an agreement. This model is mapped to existing standards and supports multi-provider projects.

Making consent follow the data

For consent, a common interface must allow the receiving side to check purpose, scope and withdrawal before every exchange. Consent may have been given in the Prometheus-X consent manager, in an Athumi Solid pod or elsewhere. A gap analysis and specification iterations are under way.

Taken up in standards

This work is being taken up in standards:

  • by the DSSC: rulebook governance layers, contract fields, self-description for federation;
  • by CEN-CENELEC JTC 25: discovery services, consent;
  • by Gaia-X: contract clauses, multi-party contracts.

Next step: an open assistant for data spaces

From a need to a governed project

The assistant lets an organisation describe its need in plain words. It searches federated catalogues, suggests offers, pre-fills the project and recommends the rules to apply, based on rulebooks and the rule bank.
The demo, run on VisionsTrust, started from a need typed in a few words and ended with a governed project. The assistant selected offers and an Edge Node Server, then built a basket with prices and conditions. It then created the project and recommended rules by role, taken from the xapi4research rulebook. Finally, the contract request was sent.

Pooling to recommend better

Today, the assistant relies on public data: about 15,000 offers from public catalogues and around 50 use cases across 8 sectors. Its suggestions are therefore limited to the data spaces Visions operates and to generic use cases. Adding contracts, rules and how they are enforced will make it more precise. Pooling this knowledge across data spaces would make it relevant for everyone. The scope, governance and business model of this pooling are to be decided together.

The workshop and next steps

The session ended with a workshop on the Mural, where each speaker led the discussion on their topic. The exchanges were numerous: participants shared the topics they want to contribute to, and several explained their proposal live. They confirm a real willingness to collaborate and build this common layer together.
Every sticky note will get an answer, whether or not it was discussed during the session. The team will come back to each contributor to define how they can take part, and the Mural remains open. To join the rulebook work, contact Olivier Dion at olivier@onecub.fr. For technical interoperability and the rule bank, contact Félix Bole at felix@visionspol.eu.

Key takeaways

Trust between data spaces cannot be decreed in a document. It is built with shared, machine-readable rules, enforced and proven at every exchange. The webinar showed that this chain already works end to end on a real case, from the rulebook to the release gate of the Edge Node Server.

It also showed what remains to be done together: agreeing on a binding L0 and translating the remaining rules. Proof verification also needs to be generalised in the connector, and bridges between stacks extended. The next milestone is set: the vote on L0 V1 and the launch of the first DSIF federation on 19 April 2027. If your data space wants to be part of it, now is the time to commit.

We thank the 121 participants and our speakers:

  • Olivier Dion (Onecub, Prometheus-X);
  • Félix Bole (Visions, Prometheus-X);
  • Nicolas Gretten (Visions);
  • László Gönczy (BME, Prometheus-X);
  • Benoit Alessandroni (StartinBlox);
  • Juanjo Hierro (Seamware);
  • Matthias De Bièvre (Visions, Prometheus-X).

If you were not able to attend the live webinar, the replay is available below. You can also access the presentation used during the webinar.

Would you like to join the DSIF federation or contribute to Prometheus-X open source building blocks? Contact us at matthias@visionspol.eu.