Thales × Spire.AIJoint research, KMIS 2026 Download paper

Thales × Spire.AI, joint research, KMIS 2026

Knowledge Graphs for Engineering Competency Upskilling in Large Enterprises

Knowledge Graphs, Large Graph Models and Neuro-Symbolic AI for contextual, explainable and auditable engineering competency reasoning.

KMIS 2026 | Joint Thales × Spire.AI research | 8-page paper

Saurabh Jain | Sandesh Pai | Juliette Mattioli
KMIS 2026 | Angers, France | Presented 30 October 2026
AbstractAs published, KMIS 2026.
Reproduced verbatim.

Large industrial enterprises in aerospace, defense, energy, automotive, and advanced manufacturing depend on their engineering workforce as their most knowledge-intensive asset, yet the tools used to model competencies remain largely static. This paper argues that knowledge graphs (KGs) provide an appropriate representational and reasoning substrate for competency management in such settings. We formalize a role–competency–mission ontology grounded in OWL 2, define a competency gap function for dynamic gap analysis, and characterize the structural advantages of KG-based representations over flat skill taxonomies. We then present the Spire.AI Large Graph Model (LGM) for Skills, a domain-aware KG comprising over fourteen million skill nodes with a self-evolving ingestion pipeline, describe its implementation stack and an end-to-end gap-analysis workflow, and propose a four-dimensional knowledge quality assessment framework spanning completeness, accuracy, timeliness, and consistency. The discussion situates the approach within the skills-based organization paradigm and the neuro-symbolic AI tradition, and outlines open challenges in cold-start handling, ontology alignment, and explainability via Graph-RAG.

Keywords: knowledge graph, context graph, large graph model, competency management, upskilling, skill adjacency, ontology, job description, gap analysis, learning pathway, EU AI Act

Explainers

Each chapter shows the figures and tables as published. Beneath each one you can open a concept explainer, an illustration drawn by Spire.AI to show how that part of the argument works. These are not figures from the paper and are tagged in amber wherever they appear.

In aerospace, defence, energy, automotive and advanced manufacturing, engineers are the most knowledge-intensive asset. Yet competency frameworks are still mostly managed in spreadsheets or legacy human capital management systems, where skills are countable attributes tied to people and roles.

That overlooks the relational nature of expertise. Formal methods proficiency both supports and depends on model-based systems engineering; embedded-systems cybersecurity is related to, but distinct from, safety-critical software engineering.

The paper makes three contributions:

  1. A Role–Competency–Mission Ontology grounded in OWL 2.
  2. A characterisation of the reasoning it enables, and of the knowledge-quality dimensions that bound its reliability.
  3. The Spire.AI Large Graph Model for Skills, which instantiates the framework as a deployed neuro-symbolic platform meeting regulated-enterprise governance constraints.
Figure 1 from the paper
Figure 1 from the paper. From Job Family to Skills. The role side of the ontology is a four-tier subsumption hierarchy: a job family group, a discipline, a key profile and a job profile. Requirements asserted higher in the hierarchy are inherited below.

Figure 1, reproduced from the paper. From Job Family to Skills. The role side of the ontology is a four-tier subsumption hierarchy: a job family group, a discipline, a key profile and a job profile. Requirements asserted higher in the hierarchy are inherited below.

02Research problem

Flat competency models lose the relationships that give knowledge meaning.

Semantic blindness. Contextual blindness. Static decay.

Competencies depend on one another. One capability may be a prerequisite for another, sit adjacent to it, or be required at a different proficiency level depending on the mission. Flat competency matrices represent skills as isolated attributes and do not explicitly preserve the semantic relationships, mission context and dependencies required for graph reasoning.

All three failures come from the same mismatch. A matrix is closed-world: whatever is not listed counts as absent. A Knowledge Graph is open-world, so a new skill or relation arrives as one more assertion rather than a change of schema, and typed edges let implicit relationships be inferred from explicit ones.

Research takeawayA flat list records what is known. A Knowledge Graph represents how that knowledge is related.
Section 4 and Table 1, from the paper

Semantic blindness

No way to show that skills reinforce, substitute or subsume each other.

Contextual blindness

Skills lack meaning outside the role, mission and technical environment.

Static decay

Flat taxonomies age immediately, with no way to propagate changes across dependencies.

Table 1, reproduced from the paper: comparison of competency-management approaches with the proposed LGM framework.
CriterionFlat matricesRef. frameworksPublic taxonomiesSpire.AI LGM
Semantic relations between skillsNone (skill–level pairs)Implicit, informalPartial (occupation links)Typed edges: prerequisite, adjacency, substitutability
Enterprise context (roles, missions)Local but rigidGenericAbsentRole–competency–mission ontology (OWL 2)
Update dynamicsManual, periodicMulti-year release cyclesSlow periodic revisionsSelf-evolving ingestion with feedback loop
Reasoning supportNoneNoneLimited lookupGap analysis, learning-path synthesis, multi-hop matching
Similarity / generalizationNoneNoneNoneLearned embedding Φ over 14M+ skill nodes
Auditability (EU AI Act)Low (opaque spreadsheets)Medium (documented but static)MediumHigh: path-based justifications, governance, bias audit
Concept explainer
Conceptual illustration, not from the paper

Flat matrix

Knowledge Graph

Hover or tap a limitation above. Both halves respond together.

Section 1 the two adjacency pairsFigure 5 one shared competency required by profiles in two job familiesIllustrative the prerequisite edge, every proficiency level, and the new skill

Explore the technical detail

Why now

The paper identifies four converging pressures: rapid technological change constantly reshapes required skills; rising mission complexity demands multidisciplinary profiles; the scale of global engineering organisations makes manual upkeep infeasible; and the workforce now includes AI agents and autonomous software workers. Regimes such as the EU AI Act also classify AI systems for employment and workforce management as high-risk, requiring transparency, traceability and non-discrimination.

03Formal knowledge representation

An OWL 2 ontology for roles, competencies, engineers and missions.

Explicit entities. Typed relationships. Formal constraints.

The research defines a Role–Competency–Mission Ontology grounded in OWL 2. Its Knowledge Graph is formally represented as

G = (V, E, O)

where V is the set of nodes, E ⊆ V × R × V the set of typed edges, and O an OWL 2 ontology providing the terminological backbone. Four primary concept classes establish the model: Role, Competency, Mission, Engineer.

Roles require competencies, engineers possess them, missions are supported by roles, and competencies relate to each other by adjacency or prerequisite. Select a relationship below to see what it means and where it is used in reasoning.

Research takeawayThe ontology makes domain relationships explicit and constrains how they can be represented.
Definition 1 from the paper
RoleCompetencyMissionEngineer

rrequires : CRole → CComp.

requires

A role profile requires competencies, each at a target level on base < enhanced < expert.

rsupports : CMission → CRole

supports

A mission profile links its objectives to the roles that support it.

rpossesses : CEng. → CComp.

possesses

An engineer holds a competency at an assessed level.

radjacentTo : CComp. → CComp.

adjacentTo

Symmetric. Semantic proximity between skills, weighted by sim(Φ(c₁), Φ(c₂)).

rprerequisiteOf : CComp. → CComp.

prerequisiteOf

The paper models prerequisite relationships as directed dependencies within an acyclic structure, enabling prerequisite-chain analysis and learning-path synthesis.

Concept explainer
Conceptual illustration, not from the paper Hover a relationship
Hover or tap a relationship, in the list or on the diagram.

Definition 1 the four classes and five object propertiesIllustrative marked per relation in the panel

Explore the technical detail

TBox and ABox

In description-logic terms, an ontology separates the TBox (terminological box), which states the classes and the relationships permitted between them, from the ABox (assertional box), which states facts about individuals.

Here the TBox says, for example, that requires connects a Role to a Competency. The ABox records that a particular role requires a particular competency. The ontology is defined using a TBox and an ABox. Candidate knowledge is constrained by the allowed concept classes and object properties described in the ontology.

O = (T, A) with TBox T and ABox A

Main object properties (Definition 1)

rrequires : CRole → CComp.
rsupports : CMission → CRole
rpossesses : CEng. → CComp.
radjacentTo : CComp. → CComp.
rprerequisiteOf : CComp. → CComp.

Weighted adjacency

OWL object properties are unweighted, so adjacency strength comes from the embedding: each edge radjacentTo(c1, c2) is weighted by sim(Φ(c1), Φ(c2)) under the LGM embedding.

Profiles

A role profile ρ specifies required competencies with target levels: Req(ρ) = {(c, ℓreq(ρ, c)) | rrequires(ρ, c)}. A mission profile μ links objectives to the roles that support them: Roles(μ) = {ρ | rsupports(μ, ρ)}, useful when an engineer works across concurrent programmes with different requirements.

04Computable reasoning

From connected knowledge to explainable competency decisions.

Gap analysis. Prerequisite paths. Adjacency. Multi-hop compatibility.

The paper defines a competency gap Δ(e, ρ): what a role requires, set against what an engineer holds, on the ordered scale base < enhanced < expert. The weighted gap score G(e, ρ) sums the strategic weight of each missing competency multiplied by the difference between required and possessed proficiency levels.

Mandatory competencies remain hard constraints. A missing mandatory competency makes an engineer ineligible for a safety-critical role, regardless of the weighted gap score.

Each inference is a path over typed edges, so every recommendation carries its own justification. That is what makes graph-based upskilling compatible with the transparency obligations of regulated settings.

Research takeawayGraph paths provide an inspectable basis for recommendations rather than an isolated compatibility score.
Figure 2 from the paperClick to explore
Enterprise &labour-market dataIngestion:dedup., normalization,entity candidatesOntology gate(OWL 2 check)Knowledge graph(Vₛ, Eₛ, Oₛ, Φ)Profile assembly:Req(ρ), Poss(e)Gap computation:Δ(e, ρ), G(e, ρ),mandatory check M(ρ)Reasoning:path synthesis,adjacency transfer,multi-hop matchRecommendations:learning pathways,redeployment,audit trailfeedback loop: observed outcomes re-ingested as evidence

Hover any part of the figure to change what is shown here

Gap computation

Evaluates the competency gap Δ(e, ρ) and the weighted score G(e, ρ), and applies the mandatory check M(ρ). A missing mandatory competency makes an engineer ineligible whatever the weighted score.

Figure 2, redrawn from the paper. The end-to-end competency gap analysis workflow. Data flows from ingestion through the ontology gate into the governed knowledge graph; profile assembly and gap computation feed the three reasoning services; operational outcomes return to ingestion.

i

Learning path synthesis

Directed traversal over prerequisiteOf yields the topological ordering of the competencies in the gap and their unmet prerequisites.

ii

Adjacency-based lateral transfer

Under the paper's adjacency-based acquisition-cost model, higher similarity between possessed and required competencies reduces the estimated cost of acquiring the adjacent competency.

iii

Multi-hop role compatibility

Two-hop inference pinpoints engineers not yet qualified for a role but nearest to it in competency space, ranked ascending.

Concept explainer
Conceptual illustration, not from the paper
Pick a question above. The graph traces the answer step by step.

Section 4 the three reasoning modes, the gap function and the mandatory-competency constraintIllustrative every engineer, role, competency, weight and proficiency level

Explore the technical detail

Levels map to ranks: base = 1, enhanced = 2, expert = 3, and 0 if absent. For engineer e assigned to role ρ, leve(c) is the level at which e holds c.

Δ(e, ρ) = {(c, ℓreq) ∈ Req(ρ) | rank(leve(c)) < rank(ℓreq)}
G(e, ρ) = Σ(c, ℓ) ∈ Δ(e, ρ) w(c, ρ) · δ(ℓreq, ℓpos)

w(c, ρ) is the strategic weight of c for ρ, and δ(ℓreq, ℓpos) = rank(ℓreq) − rank(ℓpos) is the proficiency distance, at least 1 on the gap set.

Although the graph is open-world, the gap is evaluated under a local completeness assumption on possesses: absence of an assertion is read as non-possession. For safety-critical roles, a mandatory subset M(ρ) ⊆ Req(ρ) is a hard constraint: any shortfall makes e ineligible independently of the weighted score.

Adjacency cost

cost(c2 | e) ∝ 1 − maxc1 ∈ Poss(e) sim(Φ(c1), Φ(c2))

Multi-hop candidates

Two-hop inference (engineer → possessed competency → required competency via adjacentTo) yields candidates whose |Δ(e, ρ)| or G(e, ρ) falls below a deployment threshold, ranked ascending.

05Large Graph Model

The Spire.AI Large Graph Model for Skills: Explicit Structure and Learned Similarity

The LGM is a domain-aware Knowledge Graph combining typed semantic relationships, ontology constraints and learned embeddings. Where a Large Language Model learns distributions over token sequences, an LGM learns over context graph structure: its unit of representation is a typed, interrelated entity rather than a span of text.

The ontology constrains permissible concepts and relationships. Embeddings place admitted entities in a vector space, enabling approximate similarity queries. Together they support exact traversal and learned similarity within one knowledge base.

Research takeawayFormal graph structure and learned vector representations support complementary forms of knowledge retrieval and reasoning.
14M+skill nodes in the broader Spire.AI Large Graph Model for Skills, built on 18 years of research and continuous ingestion of open web sources: labour-demand data, curricula and research literature. This is the general model, not the engineering-enterprise instantiation in chapter 9.
Definition 3 from the paper

GLGM = (Vs, Es, Os, Φ)

Vs

Skill nodes

Proficiencies, technologies, behaviours and domain knowledge.

Es

Typed semantic relations

Prerequisite, adjacent, substitutable, co-occurring.

Os

Domain ontology

Constrains which relation types are valid.

Φ

Learned embedding

Φ : Vs → ℝd, for vector-space similarity queries.

Concept explainer
Conceptual illustration, not from the paper Hover a skill in either view

Knowledge Graph view

Typed structure: exact traversal along declared relationships

Embedding space view

Learned similarity: a two-dimensional projection of vector distance. The positions here were placed by hand, so the ranking below follows from the drawing, not from a trained model.

Hover or tap a skill, in either view or in the list above.
Graph neighbours (exact)
    Nearest in embedding (approximate)Illustrative

      Definition 3 exact structure and learned similarity in one modelIllustrative every skill shown, the embedding positions, and the ranking that follows from them

      Explore the technical detail
      GLGM = (Vs, Es, Os, Φ)
      Vs
      skill nodes: proficiencies, technologies, behaviours, domain knowledge
      Es
      typed semantic relations: prerequisite, adjacent, substitutable, co-occurring
      Os
      domain ontology constraining valid relation types
      Φ
      Φ : Vs → ℝd, a learned embedding for vector-space similarity queries

      Os and Φ act in concert: the ontology admits or rejects candidate assertions, and the embedding projects every admitted node into a shared vector space. The model therefore serves exact structural queries (typed-edge traversals) and approximate similarity queries (nearest-neighbour lookups over Φ) within one coherent knowledge base.

      In the implementation, Φ is a transformer graph–text bi-encoder trained on skill descriptions and graph neighbourhoods, mapping each admitted node to ℝd with d in the low hundreds; nearest-neighbour search uses an HNSW-indexed vector store co-located with the graph.

      06Neuro-symbolic knowledge validation

      Propose. Verify. Admit.

      Statistical learning and formal ontology constraints within a self-evolving Knowledge Graph.

      Keeping a Knowledge Graph current means discovering competencies and relationships as they emerge. Statistical and language-model components propose candidates from heterogeneous evidence, but a proposal has to be evaluated before it enters the graph.

      The research describes a neuro-symbolic propose-and-verify gate at the knowledge-graph layer. The OWL 2 ontology admits only candidates consistent with the defined concept classes and object properties.

      Validated outcomes and additional evidence feed back into ingestion, so the graph can be corrected and extended over successive cycles.

      The paper specifies that the OWL 2 ontology admits only candidate assertions consistent with the schema. Accuracy is addressed separately through the Knowledge Quality Assessment framework.

      Research takeawayNeural components propose candidate knowledge; formal ontology constraints govern its admission into the Knowledge Graph.
      Figure 4 from the paperClick to explore
      Extractorsstatistical and LLMcandidateOntology gateOWL 2 checkadmitKnowledge graphtyped nodes, edges, ΦrejectDiscardoutcomes feed back (self-evolving)

      Hover any part of the figure to change what is shown here

      Ontology gate

      The OWL 2 check. The ontology gate rejects candidate assertions that are inconsistent with its allowed concept classes and object properties.

      Figure 4, redrawn from the paper. The neuro-symbolic propose-and-verify gate at the knowledge-graph layer. Statistical and language-model components propose candidate assertions; the OWL 2 ontology admits only those consistent with the schema; validated outcomes feed back as evidence.

      Concept explainer
      Conceptual illustration, not from the paper
      Pick a candidate, then run it through the gate. Candidate C is the interesting one.

      Candidate assertion

      Ontology gate checks

        The gate illustrates domain and range checks. Full OWL 2 consistency reasoning also considers applicable property characteristics, disjointness and cardinality constraints defined in the ontology.

        Figure 4 and Definition 1 the propose-and-verify gate, and the class each relation must start and end atIllustrative all three candidate assertions

        07System architecture

        Five layers connecting enterprise evidence to knowledge-based applications.

        A governance harness and a feedback loop span the architecture.

        Data moves from raw enterprise sources to decision-ready applications through five layers. Two structures span all of them: a governance harness enforcing access, policy, privacy, security, audit and compliance, and a feedback loop returning acquisition outcomes, validated recommendations and new role requirements to ingestion.

        That closed loop is what makes the model self-evolving. Unlike a static taxonomy, the graph is corrected and extended continuously.

        Research takeawayThe architecture integrates heterogeneous ingestion, formal knowledge representation, contextual matching, graph reasoning and applications with cross-cutting governance.
        Figure 3 from the paperClick to explore
        Humans and agentic supplyengineers, users, agents, workersGovernance harnessaccess, control, policy, privacy, security, regulation, audit, complianceGovernance and assurance: ISO 27001 · SOC 2 Type II · GDPR · independent bias auditApplicationinsights and orchestrationReasoningdeterministic gap and path inferenceContextualization and matchingintent, context, alignmentKnowledge graphontology-governed graph and embeddingsIngestionnormalize and validate sourcesFeedbackEnterprise and labour-market datarecords, logs, documents, signals

        Hover any part of the figure to change what is shown here

        Layer 2, Knowledge graph

        Stores validated knowledge as the typed property graph governed by an OWL 2 ontology that constrains admissible assertions. This is where the propose-and-verify gate sits.

        Figure 3, redrawn from the paper. The Spire.AI LGM functional reference architecture: five layers, a cross-cutting governance harness, and a feedback loop.

        08Knowledge quality assessment

        A self-evolving Knowledge Graph requires measurable quality.

        Completeness. Accuracy. Timeliness. Consistency.

        Continuously incorporating new information creates a trade-off between freshness and reliability. Faster ingestion can improve timeliness while increasing the risk of inaccurate or inconsistent assertions.

        The research proposes a four-dimensional assessment framework, extending the KQI model of Mattioli et al. (2025) to the HR domain. Each dimension carries the specification target the paper sets for it.

        The dimensions pull against each other: pushing timeliness can cost accuracy and consistency. The architecture manages this trade-off by favouring accuracy and consistency through ontology-governed admission, while the feedback loop addresses timeliness over successive ingestion cycles.

        Research takeawayThe reliability of graph-based reasoning depends on the quality, consistency and currency of the underlying knowledge.
        Table 2 from the paper
        Table 2, reproduced from the paper: knowledge quality dimensions for engineering HR knowledge graphs.
        DimensionDefinition and metricTarget
        CompletenessFraction of required role–competency edges populated: κc = |Epres| / |Ereq|≥ 0.95
        AccuracyAgreement with validated expert profiles: κa = 1 − Ferr≥ 0.90
        TimelinessMedian lag between skill emergence and integration (days)≤ 30 d
        ConsistencyFraction of ontology constraints satisfied: κco ∈ [0, 1]1.0

        KQI = w₁κc + w₂κa + w₃κ′t + w₄κco

        κ′t is a normalised timeliness score in [0, 1] and the weights sum to one. A programme is deployment-ready when its KQI exceeds an agreed threshold, for example 0.90. These are specification targets, not measured results.

        Explore the technical detail

        The dimensions aggregate into a single Knowledge Quality Index for deployment readiness:

        KQI = w1κc + w2κa + w3κ′t + w4κco

        κ′t is a normalised timeliness score in [0, 1] and the weights sum to one. A programme is deployment-ready when its KQI exceeds an agreed threshold (for example, 0.90).

        Two caveats from the paper: accuracy and completeness depend on the coverage and currency of the expert-validated ground truth, and reported values reflect the engineering domains sampled rather than every role family, so the targets should be read as deployment specifications. The paper’s conclusion states that the model meets these targets in the evaluated domains; it does not report individual measured values.

        Neither the dimensions nor the index depend on anything specific to engineering, so the same KQI applies to recruitment, internal mobility, workforce and succession planning, and learning and development.

        09Industrial engineering instantiation

        An industrial-scale Knowledge Graph connecting roles, competencies and learning resources.

        An engineering-enterprise instantiation of the formal ontology and graph representation.

        An instantiation of the LGM for a large engineering enterprise exercises the ontology at production scale. The role side spans five job families, 21 disciplines and 90 job profiles. The competency side separates 394 curated catalogue skills from 2,251 demand skills observed in open jobs. The learning side relates these to 6,086 skills drawn from 960 training materials across 19 colleges and five academies.

        The industrial instantiation exposes shared competencies and development routes across job families, supporting gap analysis, learning-path synthesis and adjacency-based transfer.

        Research takeawayShared competency nodes reveal relationships and learning routes that isolated organisational classifications can leave implicit.
        Figures 5 and 6 from the paper, shown together
        Figure 5 from the paper. Catalogue-skill neighbourhood for Cybersecurity Principles. The skill is required by profiles in two job families and is delivered through a dedicated college, so one shared node connects both families to the same training.

        Figure 5, reproduced from the paper. Catalogue-skill neighbourhood for Cybersecurity Principles. The skill is required by profiles in two job families and is delivered through a dedicated college, so one shared node connects both families to the same training.

        Figure 6 from the paper. Demand-skill neighbourhood for Software Architecture. The skill is required by job profiles that resolve to three distinct job families, an instance of the competency-hub property.

        Figure 6, reproduced from the paper. Demand-skill neighbourhood for Software Architecture. The skill is required by job profiles that resolve to three distinct job families, an instance of the competency-hub property.

        Explore the technical detail

        Modelling skills as nodes lets the organisation query its workforce as a network. Each of these is a standard query over the graph:

        • Competency hubs: nodes of high in-degree over requires. Software Architecture is one.
        • Vulnerability nodes: skills whose required-by count greatly exceeds their possessed-by count.
        • Learning leverage points: competencies whose acquisition maximally reduces the aggregate gap Σρ G(e, ρ).

        In regulated settings the same graph that locates a gap also produces auditable evidence that a team meets its mandated competencies.

        10Research conclusion

        From isolated competency attributes to relational, explainable engineering knowledge.

        The research concludes that Knowledge Graphs provide a suitable representation and reasoning substrate for competency management in large engineering enterprises. The Role–Competency–Mission Ontology formalises the relationships between engineers, roles, competencies and missions; graph reasoning supports gap analysis, learning-path synthesis, adjacency-based transfer and multi-hop compatibility.

        The Spire.AI Large Graph Model combines ontology-governed structure with learned embeddings; the propose-and-verify gate introduces formal constraints into the admission of candidate knowledge; quality assessment and governance address reliability, traceability and continuous evolution. The industrial instantiation shows how shared competencies and development routes can be represented across organisational boundaries.

        Only a densely relational representation supports dynamic, contextualised, personalised upskilling and, in regulated settings, makes such decisions auditable under emerging AI regulation such as the EU AI Act.

        1. Formal ontologyRole, Competency, Mission, Engineer in OWL 2
        2. Large Graph ModelTyped structure with learned embeddings
        3. Neuro-symbolic validationNeural proposals, ontology admission
        4. Graph reasoningGaps, paths, adjacency, multi-hop
        5. Knowledge quality and governanceFour dimensions, cross-cutting harness
        Central conclusionCompetencies should be represented not as isolated attributes, but as nodes in a densely relational structure.

        Open challenges identified

        • Cold start. Limited data for newly onboarded engineers or freshly defined roles undermines gap-analysis robustness. Pre-training on global demand data lets a new role inherit structure from analogous roles, and adjacency yields provisional estimates; enterprise-specific calibration remains open.
        • Ontology alignment. Linking the LGM to organisation-specific taxonomies needs precise semantic mapping; the open problem is maintaining that mapping as labels drift.
        • Explainability. Super Agent Sigma already generates natural-language justifications grounded in graph structure. The paper identifies Graph-RAG as a promising approach for combining LLMs with Knowledge Graph reasoning, while rigorous evaluation of the explanations' faithfulness to the underlying graph paths remains an open challenge.

        Future research directions

        • Formal integration with hybrid AI architectures for safety-critical certification
        • KQI-based monitoring dashboards
        • Category-theoretic modelling of the evolving skills graph
        • Temporal and causal reasoning: anticipating which competencies will emerge or decline
        • Extending gap analysis to combined human-and-agent workforces, since the model also defines AI agent and autonomous worker skills

        A Knowledge-Graph Perspective on Education System Design

        The paper also discusses the prospective application of the same relational model to education-system design. Knowledge Graphs can represent shared competencies across educational streams and institutions, model prerequisite relationships and support learning-path recommendations. The approach also considers cross-disciplinary relationships and multilingual ontology alignment. This discussion is prospective and does not report a deployed educational system.

        Read the complete research

        Knowledge Graphs for Engineering Competency Upskilling in Large Enterprises

        Saurabh Jain | Sandesh Pai | Juliette Mattioli
        Thales × Spire.AI | KMIS 2026, Angers, France

        • Eight pages
        • Three authors
        • KMIS 2026
        • Knowledge Graphs and Large Graph Models
        • Formal ontology and graph reasoning
        • Industrial engineering instantiation

        The full paper contains the formal ontology, gap definitions, the end-to-end gap-analysis workflow, the LGM architecture and implementation stack, the knowledge-quality framework, the published Figure 5 and 6 neighbourhoods, limitations and the education-system perspective.