You’re listening to “A Neurosymbolic Multi-Agent System for Explainable and Traceable Decision-Making in Organizational Contexts,” by A. Mertzani and colleagues. Published in 2026.

Abstract.

The increasing use of Generative Artificial Intelligence (AI) in Human Resource Management (HRM) raises critical challenges for transparency, explainability, and accountability. While Large Language Models (LLMs) offer powerful natural-language interfaces, their tendency to hallucinate and their non-transparent reasoning limit their suitability for decision-making in HR contexts. We propose a transparent-by-design neurosymbolic decision-support system that integrates a provenance-aware knowledge graph with a modular multi-agent architecture and a constrained LLM interface.

A scenario-based evaluation on a public HR dataset using a set of operational, strategic, and evidence-retrieval HR analytics queries shows that the system achieves mean fact-level performance of F1 = 0.677, mean traceability completeness of 0.680, hallucination resistance of 0.733, and mean end-to-end latency of 0.067 seconds, alongside a query-level accuracy of 0.733. The paper contributes to Information Retrieval and Generative AI research by illustrating how neurosymbolic grounding, provenance-aware retrieval, and agent-based architectures can enable trustworthy and governable information systems.

Introduction.

The rapid digitization of Human Resource Management (HRM) has accelerated the adoption of data-driven decision-support tools. Generative and conversational Artificial Intel-ligence (AI), particularly Large Language Models (LLMs), are now playing an increasingly prominent role in résumé screening, performance evaluation, internal mobility analysis and training. Although recent studies show that LLMs can extract meaningful signals from HR data and at times match or surpass human consistency, they also reveal persistent risks. For example, recent studies demonstrate

The associate editor coordinating the review of this manuscript and approving it for publication was Zijian Zhang.

that LLM-based retrieval systems in résumé screening disproportionately favor white-associated names (up to 85% of the time) and disadvantage black males in simulated experiments (in some cases up to 100%). In addition, LLMs remain prone to hallucination, inconsistent factual retrieval and the blending of unverifiable assumptions with genuine information, important limitations that are especially problematic in contexts where decisions affect careers, evaluations and organizational practices and must therefore satisfy fairness, provenance and governance requirements. Besides, current systems rarely reveal the data they rely on or the steps through which conclusions are produced, thus HR professionals are often unable to audit, contest or even validate the outputs they receive from such systems.

For addressing these limitations, retrieval-augmented gen-eration and provenance-aware AI architectures have emerged as promising directions for trustworthy HR decision-support systems. Instead of relying exclusively on internally gener-ated outputs, retrieval-augmented approaches enable LLMs to ground their responses on external and structured knowl-edge sources, therefore, reducing unsupported inferences and improving factual consistency. Recent studies further empha-size the importance of provenance-aware and auditable AI pipelines capable of recording the origin of retrieved informa-tion, intermediate reasoning steps and supporting evidence.

In particular, retrieval-augmented generation is important for HR decision-support because it can connect large language models with external, structured knowledge instead of relying only on model-generated text, as shown by the knowledge-graph-enhanced question-answering approach of. In HR, this matters because decisions should be based on relevant evidence, clear criteria and domain-specific knowledge. Provenance-aware AI systems are also important because they provide the means to record the source of data, rules and/or recommendations, enabling controlled access and traceability, which is particularly relevant for recruitment and HR services, where AI outputs may have an impact on peoples’ opportunities and, as such, need to be explainable, checked and justified.

Recent HR-focused work also shows the need for interpretable AI models in recruitment and for large language models adapted to HR services. In high-stakes HR contexts, where AI-assisted outputs may influence recruitment, promotion and evaluation decisions, such capabilities are increasingly viewed as necessary foundations for explainability, governance and accountable human–AI collaboration.

Existing HRM literature increasingly reinforces these concerns and highlights the importance of transparency, explainability and accountability in AI-assisted decision-making. For instance, the authors in report that organizations are increasingly deploying Generative AI tools in HRM but these systems lack transparency, traceability and rigorous assessments of fairness, ethics and explainability and, thus, fail to support collaborative human–AI decision-making. Similar findings are also reported in where the authors argue that socially acceptable HR–AI collaboration requires designing for explainability, stakeholder trust and high-stakes accountability.

An increasing body of research has begun to quantify these biases and propose benchmarking frameworks to audit fairness in LLM-based HR applications. In particular, JobFair and FAIRE introduce measurable indicators (such as the Rank-After-Scoring metric and Impact Ratios) to detect gender and racial disparities in automated hiring tasks. Similar studies provide rigorous experimental evidence of systematic demographic disadvantages in the selection of résumés, while other studies articulate fairness principles, including demographic parity and equal opportunity, as gov-ernance anchors for AI-enabled recruitment. This body of literature offers a growing set of instruments for evaluating fairness and detecting bias in algorithmic HR systems.

However, it should be noted that benchmarking alone is insufficient, and thus ensuring responsible AI in HRM requires systems that do not simply comply with fairness metrics post hoc, but embed explainability, transparency and human oversight from the beginning.

HRM analytics increasingly relies on structured and relational representations to capture the complexity of organizational data and to support more rigorous, data-driven decision processes. Graph-based modeling has become particularly influential, enabling HR systems to represent relationships between candidates and job postings, to model reciprocal interactions among users, and to structure connec-tions between employees, skills, courses, and labor-market opportunities. Recent work demonstrates how graph neural networks and graph autoencoder architectures can support inductive candidate–job matching and outcome prediction in employment-related settings, highlighting the value of relational structure for addressing sparsity, cold-start condi-tions, and dynamic organizational environments.

These approaches show that heterogeneous and multiplex graph structures can encode rich organizational, behavioral, and competency-related information, enabling more nuanced analysis, personalized matching, and evaluative insight.

Despite substantial advances in knowledge graph (KG) construction, multi-agent systems (MAS), and Generative AI, key system-level gaps remain unresolved in the HRM literature. While KGs provide semantically structured rep-resentations and MAS architectures enable modular compu-tation, existing HRM solutions, to our knowledge, have not yet integrated these paradigms into a unified decision-support framework that is transparent, accountable and aligned with organizational governance requirements. In particular, prior approaches lack: (i) a multi-agent architecture that decomposes HR analytics into explicitly interpretable and attributable components, (ii) a provenance-aware KG that encodes HR information with fine-grained traceability across heterogeneous sources, and (iii) a reasoning pipeline that strictly bounds generative outputs to verifiable, graph-retrieved evidence.

As a result, explanations are often implicit, provenance is partial or absent, and human oversight is limited.

In response to these challenges, this paper introduces a transparent-by-design neurosymbolic multi-agent decision-support architecture for explainable and traceable HR information access and organizational decision-making. The proposed system integrates a conversational natural-language interface with a modular multi-agent orchestration layer and a provenance-aware RDF KG that functions as the system’s single source of truth, thereby combining neural generative capabilities with symbolic and auditable knowledge repre-sentations. Explainability and traceability are embedded at the architectural level through three complementary mecha-nisms: the provenance-aware KG, the modular multi-agent orchestration layer, and the strictly evidence-grounded LLM interface.

In particular, all generative responses are constrained to evidence explicitly retrieved from the KG, where each fact is represented as an auditable Resource Description Framework (RDF) triple linked to its source document, producing agent, timestamp, and confidence metadata. Specialized agents are responsible for extraction, statistical analysis, and operational aggregation, while an explicit routing mechanism renders coordination, reasoning flow and responsibility allocation visible and inspectable. The scenario-based evaluation demonstrates that this design supports reliable fact retrieval, systematic traceability, low response latency, and increased resistance to hallucination across operational and strategic HR analytics queries, while exhibiting deterministic and reproducible behavior in contrast to API-based LLM baselines.

Overall, the work contributes a reusable architectural blueprint for governable generative information systems (IS), advancing research at the intersec-tion of IS, Information Retrieval (IR) and recommendation by showing how neurosymbolic grounding and agent-based design can support reliable, auditable and human-aligned organizational decision-making.

The remainder of the paper is organized as follows. Section II reviews the relevant literature. Section III intro-duces the proposed neurosymbolic multi-agent architecture. Section IV describes the system’s implementation, including data ingestion and fact extraction, agent coordination, query routing and evidence construction mechanisms. Section V presents a scenario-based evaluation of the system’s per-formance, traceability and robustness in representative HR analytics tasks, while Section VI provides a comparative analysis against general-purpose LLM baselines. Section VII discusses the implications of the proposed approach for trans-parency, explainability, trust and governance in AI-supported HR decision-making and further reflects on its limitations as directions for future research. The paper ends with some concluding remarks and key takeaways.

II. BACKGROUND AND RELATED WORK.

For positioning our contribution within the broader landscape of knowledge-driven and explainable AI, we organize the relevant literature into four interconnected streams. In particular, the first stream comprises multi-module, multi-task architectures in which KGs constitute the semantic backbone linking information extraction, multi-modal or temporal representation learning and downstream reasoning. The second stream encompasses ontology engineering and KG construction frameworks where the focus lies on schema design, domain modeling and extraction workflows for transforming heterogeneous data sources into structured knowledge bases. The third stream includes entity, relation and joint extraction models that populate KGs by converting unstructured text (and, in some cases, multi-modal inputs) into machine-readable triples.

The fourth stream, which spans both representation learning and KG-driven reason-ing, covers methods for embedding structured knowledge, modeling relational coherence and performing collective or symbolic–neural inference over graph-structured data.

Several studies present end-to-end KG–centric archi-tectures that integrate multiple coordinated modules, spanning information extraction, multi-modal or temporal representation learning and graph-based reasoning within a unified pipeline. In financial forecasting, for instance, the authors in introduce MI-FinText, a multidimensional framework that couples financial text mining with temporal graph convolutional networks, dynamic KG construction and multi-task learning to jointly model sentiment, event structure and market value fluctuations. Similarly, in biomedical analytics, the authors in present MKG-GC, a multi-task learning framework for automating the construction of KGs across heterogeneous corpora. multi-modal reasoning architectures extend this paradigm.

For example, the authors in propose MKGFA, which constructs a multi-modal KG combining visual, textual and factual information and supplements it with a fact-assisted reasoning module to enable complex cross-modal inference in VQA tasks. The authors in similarly advance multi-modal recommendation through Multi-KG4Rec, integrating visual and textual signals within a unified KG and employing cross-modal attention and GNN propagation to enhance relational modeling. In sentiment analysis, the authors in develop AMIFN, which fuses textual, syntactic, semantic, and visual cues and constructs a knowledge-enhanced graph to propagate structured context for aspect-based sentiment classification.

Finally, the authors in introduce ATC-SD Net, a diarization framework for aviation communications that uses a state-transition graph of flight identifiers, enriched with real-time radar data, to resolve pilot identities through structured and probabilistic reasoning.

Research on ontology engineering and domain-specific KG construction has produced diverse methodologies for structuring heterogeneous information in support of inter-pretable and logic-grounded reasoning. In the manufacturing domain, the authors in develop a hierarchical KG frame-work that integrates product information, machining features, operational knowledge, and tooling relations into a unified semantic ontology. Complementing this, the authors in provide a comprehensive review of solubility-focused KG methodologies, covering data acquisition, ontology design, extraction of entities and relationships, alignment, fusion, and reasoning through logic rules, embeddings and graph convolution.

Building on these principles, the authors in propose a data-driven machining process knowledge base that combines fine-grained ontology modeling with neural information extraction—specifically a BERT–BiLSTM–CRF model trained within a federated learning framework— to construct a process KG suitable for intelligent CAPP systems. The authors in introduce a top-down/bottom-up KG framework that integrates equipment entities, fault logic, and historical case knowledge to support semantic querying and rule- or case-based reasoning for fault handling. In the authors integrate heterogeneous data, ranging from legal documents to corporate announcements, using a top-down schema and a hybrid extraction pipeline combining rule-based methods and CasRel–FinBERT.

Meanwhile, in the aviation-sector context, the authors in propose an ontology-guided extraction system using BERT, BiLSTM and CRF, subsequently linking extracted entities into a Neo4j KG that captures technical relationships among assets, components and control elements. Finally, the authors in present KeyphraseDS, which constructs a keyphrase affinity graph combining knowledge-based and topic-based similarity to cluster scientific concepts into semantically coherent aspects.

A substantial body of research advances the extraction of entities, relations and triples to support high-quality KG population, with recent work emphasizing robust-ness to ambiguity, structural complexity and heteroge-neous data sources. Joint extraction methods have become central to this effort. The authors in introduce ROMGCJE, a relation-oriented architecture that integrates BERT–BiLSTM encoding, dilated convolution, multi-head attention and a relation-guided gating mechanism to address overlapping triples in unstructured text. Similarly, propose a joint extraction model that captures multi-triple dependencies through a BERT encoder, sequence tagging for candidate triples and a non-autoregressive ‘‘rethinking structure’’ that re-evaluates triple sets via self- and cross-attention.

The authors in present the Multi-Grained Lat-tice Transformer (MGLT), which integrates lexicon-derived words and word-sense signals through cross-Transformer fusion to mitigate ambiguity and entity overlap in Chinese military-domain texts. In addition, the authors in develop ETFRE, a type-aware Transformer framework that augments BERT embeddings with entity-type vectors. Through the incorporation of symbolic category information into semantic representations, ETFRE enhances relation disambiguation and improves performance across multiple datasets. The authors in introduce BioREx, which inte-grates heterogeneous biomedical relation-extraction corpora into a unified dataset through systematic harmonization of spans, granularity and annotation scope.

Meanwhile, the authors in propose BERN2, a multi-task NER and normalization system combining neural and rule-based methods to support large-scale biomedical KG construction. The authors in present a hybrid ERNIE–BiGRU– IDCNN model with bilinear attention and CRF decoding to extract aviation-related entities, thus enabling structured information management in safety reporting. Reference propose SEMFF-CER, which fuses lexical, sub-character and contextual semantic features via a gating mechanism to improve Chinese entity recognition under ambiguity and data scarcity. Reference introduce AgriFuseNER, a dual-stream text–image architecture with dynamic cross-modal gated attention that enables precise entity extraction from paired agricultural data.

Finally, the authors in propose DKG-FRD, a dynamic multi-modal KG framework for fake-review detection, combining BLSTM-based extraction, mutual-information edges, temporal segmentation, and iter-ative reasoning over four interpretive indicators (trustiness, honesty, splendour, reliability).

Research on KG representation learning and graph-based reasoning has advanced substantially in recent years, with a focus on improving the expressiveness, structural fidelity and inferential capabilities of graph-centric models. The authors in introduce KRL-NER, a representation learning framework that enriches traditional KG embeddings by incorporating the number of relations associated with each entity—an intuitive yet previously underutilized semantic signal. A complementary direction concerns collective infer-ence over graph structures. The authors in present ELEA, a multi-objective evolutionary algorithm that jointly resolves multiple ambiguous entity mentions by optimizing for contextual compatibility and cross-entity coherence. Several works extend graph reasoning to complex operational or domain-specific environments.

The authors in develop a large-scale, multi-graph framework for power grid fault handling, integrating equipment entities, procedural logic, and historical cases into a structured model layer that supports semantic querying and rule-based and case-based reasoning. Other studies focus on graph fusion and structural learning, offering insights into how heterogeneous graph signals can be combined. The authors in propose the Graph Fusion Network (GFN), which constructs mul-tiple homogeneous word-level graphs (co-occurrence, PMI, semantic similarity) and fuses them through a multi-stage pipeline comprising graph learning, graph convolution, and logit-level fusion. Finally, the authors in introduce a DAT-MT accelerated graph fusion dependency parser that integrates domain-specific and general syntactic graphs through maximum spanning tree optimization.

The method achieves notable gains in parsing accuracy and efficiency, demonstrating how graph fusion can strengthen structural reasoning in low-resource, domain-specific settings.

Despite the substantial progress captured across these four streams, the current literature remains fragmented with respect to the system-level requirements that define high-stakes HRM decision support. End-to-end KG-centric architectures typically prioritize predictive performance, multi-modal fusion, or task coupling, but rarely make provenance a first-class design object or expose reasoning pathways in a form that supports organizational audit and contestability. Ontology- and construction-oriented frame-works provide rich schemas and extraction workflows, yet often stop at machine-level structuring without mecha-nisms for user-facing verification, accountability assignment, or interaction design that preserves meaningful human control.

Likewise, extraction and representation-learning advances strengthen the KG population and inference, but generally treat explainability as an implicit by-product of structure rather than an explicit interfaceable property of the overall pipeline—leaving unresolved how factual claims are justified, which component produced them, under what confidence, and how uncertainty propagates into managerial recommendations. Our architecture is designed to directly address these gaps in a conservative, governance-aligned way. For example, by combining a provenance-enriched RDF fact substrate (linking each claim to source, timestamp, producing agent, and confidence), a modular multi-agent orchestration layer that renders responsibility and task decomposition explicit, and a grounded evidence assembly mechanism that surfaces ranked, source-attributed facts alongside every response.

In doing so, we reposition KGs from being merely a semantic backbone for downstream learning to becoming an evidence-centric accountability infrastructure, notably one that is deliberately tailored to the transparency, explainability and trust constraints of HRM settings, while remaining compatible with neurosymbolic reasoning and conversational access.

III. SYSTEM ARCHITECTURE DESIGN.

The design begins from a simple question: What is required for a system to respond to complex, ambiguous, and context-dependent HR queries in a way that is both explainable and operationally robust? A purely neural approach — however sophisticated its internal represen-tations — cannot guarantee that its outputs correspond to verifiable information. Yet a purely symbolic system, even one augmented with a graph database or ontology, lacks the fluency and interpretive flexibility needed for conversational interfaces. The architecture therefore weaves the two approaches together. Encoded as a provenance-aware KG, symbolic representations capture structural regularities and make sure that every factual claim is linked to a source that can be traced.

Neural components, mediated through an LLM, handle linguistic interpretation, conversational flow, and the refinement of natural-language summaries. Statistical agents offer an additional mode of reasoning: numerical analysis and pattern extraction from structured data.

The design of the proposed system follows a layered architectural logic that brings together symbolic struc-ture, statistical computation, and generative reasoning in a unified environment for information access. At its core, the architecture reflects an emerging shift in AI and IS: away from monolithic intelligent components and toward more composable agentic systems equipped with structured memory, transparent decision pathways, and human-centered interaction models. Although this hybrid design reflects broader movements in contemporary AI — particularly the resurgence of neurosymbolic approaches and agentic coor-dination — its foundation is based on the Human-Centered AI (HCAI) design framework.

According to the HCAI, AI systems should be designed in a way that optimizes computational efficiency, but also extends human interaction, maintains meaningful control and promotes ethical, transpar-ent and reliable operation.

A. DESIGN PRINCIPLES

The system design started with the identification of the tensions that characterize AI-mediated decision-making in HR environments: ambiguity in employee-related data, ethical risks in automated recommendations, the need to justify managerial decisions, and the expectation that AI should enhance, not displace, human judgment. The design principles were mapped directly onto the pillars of the HCAI framework:

• Balance of human control and automation: The system must automate retrieval, aggregation, and synthesis without overriding or narrowing the user’s decision space. Automation is deployed to reduce manual burden, but always within a structure that surfaces evidence, clarifies uncertainty, and leaves interpretive authority to the human.

• Reliability, Safety and Trustworthiness: Trust cannot be earned through performance alone; it requires predictability, auditability, and procedural consistency. To that end, the architecture incorporates symbolic knowledge representations, controlled computation pathways, and safeguards against hallucination.

Transparency is • Transparency and Explainability: achieved not only through post-hoc explanations but through design choices that make reasoning steps inherently inspectable: provenance-rich facts, explicit agent roles, and structured decomposition of user queries.

• Fairness, Ethics and Accountability: In HR settings, informational asymmetry can have material conse-quences. Embedding traceability, statistical rigor, and audit trails into the system is essential for maintaining fairness and enabling accountability.

B. HIGH-LEVEL DESCRIPTION

The architecture consists of three interdependent layers, the user interaction, the multi-agent orchestration, and the KG, as illustrated in Figure 1. The former layer corresponds to the frontend and provides the interface with the user and supports their interaction with the system. In the backend, the multi-agent orchestration layer analyzes tasks, routes queries and synthesizes individual results. In close communication with those, there is the knowledge and computation layer, where structured representations, statistical routines and graphs capture the internal dependencies to produce reliable and explainable answers. Each layer has a distinct role, but they work together in a continuous exchange of signals, con-straints, and clarifications in order to produce interpretable knowledge artifacts.

This modular layering ensures that the system remains an assistant, not an autonomous decision-maker.

C. USER INTERACTION LAYER

The interface of the system is responsible for making the information from uploaded documents easily accessible to the HR professionals. Therefore, this layer of the system is built as a React application with TypeScript, making use of a component-based architecture that provides a unified user experience for interacting with the KG system. In more detail, the application employs a layered state management approach combining React Context for KG state (facts, nodes, and edges) with TanStack Query for server state synchronization, ensuring real-time updates and consistent data flow between the user interface and backend API.

The architecture features a centralized API client that communicates with the FastAPI backend through RESTful endpoints, handling document uploads, knowledge base operations, graph visualization data, chat interactions, and agent system queries with adaptive timeout mechanisms based on file size and processing complexity.

The interface provides multiple interconnected views which can be accessed through a sidebar navigation sys-tem: a conversational chat interface for natural language queries that displays responses with supporting evidence facts, an interactive KG visualization which enables users to explore entity relationships visually, a comprehensive knowledge base table view that shows facts extracted directly by documents or inferred from those, a statistics dashboard presenting correlations and distributions extracted from the data, an agent network visualization showing the multi-agent system architecture, and document management pages for uploading and tracking processing status of HR documents.

It is worth noting that although both knowledge base and KG views are available, they are both assigned to the same agent (e.g. KG agent) since they present the same information in a different way to support both table-based identification and search of facts, as well as network view of their correlations. Overall, all components are built using a consistent design system and offer responsive interaction patterns, including loading and progress indicators, as well as structured error handling.

D. MULTI-AGENT ORCHESTRATION LAYER

The main back-end layer of the systems corresponds to a multi-agent orchestration layer, which operationalizes the distributed reasoning model that underpins the overall archi-tecture. Complementing the interface layer, which focuses on making information accessible and interpretable, and the KG layer, which corresponds to the main (semantic) storage supporting provenance, the multi-agent layer is responsible for allocating responsibilities to independent, yet networked and interrelated, components (e.g agents). This is designed based on established principles of distributed information processing which involve heterogeneous processing units operating over a common space of representation such that complex behavior emerges through coordination.

Each agent has relatively limited, responsibilities, but the system as a whole (comprising multiple ‘‘simple’’ agents) executes complex tasks. Document Agents manage each a specific source (i.e. uploaded file) and allocate its processing to Worker Agents which perform low level tasks related with the extraction and transformation of content from the corresponding document. This separation of responsibilities enables horizontal scalability, since addi-tional Workers can be instantiated to handle larger datasets. Additionally, the Operational Query and Statistics Agents compute abstractions that encapsulate statistical regularities and organizational indicators, while the Visualization Agent animates statistical information through descriptive graphs.

Those agents work in parallel while the extracted facts, corresponding to document content, statistical patterns, and aggregated insights, are stored in the knowledge base as RDF triples enriched with provenance metadata that identifies both the originating document and the producing agent. This capability for concurrent processing corresponds to a main architectural advantage of the multi-agent organization, reducing substantially the processing time while preserving the provenance of the produced facts. Specifically, documents can be decomposed into independent chunks, allowing multiple Worker Agents to extract facts in parallel; likewise, analytical tasks can run concurrently, enriching the graph incrementally as results become available.

Moreover, communication between agents is achieved fundamentally through the KG Agent, which interacts with the Document, Statistics and Operational Query Agents. This mediated form of interaction keeps agents loosely coupled and allows the system to evolve without compromising coherence. Additionally, the Orchestrator Agent receives user queries from the HR Assistant Agent, analyzes those, identifies appropriate agents that have relevant information, and routes queries, respectively. The resulting outputs are integrated into a unified response enriched with evidence (e.g. supporting facts and source attribution).

Overall, the resulting architecture is illustrated in Figure2 and is designed to support HR professionals in making knowl-edgable decisions by making information easily accessible, traceable, and transparent. Inspired by human organizational structures, in which specialized expertise is coordinated to achieve collective understanding, the system leverages distributed information processing components to provide unified outputs that enable users to seamlessly interact with it without having advanced technological capabilities or technical expertise. Hence, this architecture is human-centered, modular, and supports evidence-based decision-making.

E. KNOWLEDGE GRAPH LAYER

The KG layer, which constitutes the main storage of the system maintaining facts extracted by source documents by the corresponding agents, is implemented using RDFLib and follows the RDF model. Within this layer, each fact is represented as a Subject–Predicate–Object triple, enriched with additional metadata that captures its provenance and quality. Apart from storing information regarding the docu-ment from which each fact is extracted, the KG layer also stores metadata related with the time at which that document was uploaded and processed, the identifier of the agent that produced the fact, a numerical confidence score expressing the reliability of the extraction, and an indicator specifying whether the fact was directly extracted from the input or inferred from other facts.

In this way, the KG not only stores content, but also encodes when, how, and by whom each assertion entered the system.

The architecture of this layer is designed to provide a uniform, semantically rich interface to all higher-level com-ponents, having efficient mechanisms for storing, retrieving and updating facts. Additionally, it supports responding to user queries with structured information that provides evi-dence of both the core triples and their associated metadata. To ensure robustness and continuity of operation, the graph is periodically persisted to disk using a binary snapshot, complemented by a JSON-based backup that facilitates recovery under situations of failure. This dual persistence strategy allows the system to balance performance in day-to-day use with the ability to export, inspect, or restore the knowledge base when required.

Another critical design requirement for the system is to be able to represent entities across documents and time in a unified consistent way. Therefore, the system applies an entity normalization process that maps different forms of the same underlying entity to a single canonical representation. Variants such as differences in capitalization, spacing, or minor punctuation are reconciled so that, for example, multiple textual forms of an employee name are treated as a single entity within the graph. This normalization step avoids having duplicate information, improves the quality of the facts and consequently the system outputs, and contributes to the overall coherence of the stored knowledge.

Furthermore, facts are added to the KG through a hybrid extraction pipeline. For unstructured text, the system com-bines pattern-based techniques (such as regular expressions) with optional language-model-based extraction, to identify relevant entities and relations, validate them, and assign confidence scores before inserting them into the graph together with their metadata. For structured sources such as CSV files, each row is treated as a data record and systematically mapped to triples according to the semantics of the columns. In both cases, the system’s aim is to transform heterogeneous HR data into a unified, machine-readable representation that can be understood by analytical components as well as user-facing services.

In general, the KG layer of the architecture is tightly connected to the KG component at the back. Other parts of the system do not interact with RDF structures directly; instead, they transfer information to the KG which is responsible for creating, updating and retrieving facts. This separation of responsibilities encapsulates all concerns related to triple management, metadata handling, normalization, and persistence behind a well-defined interface. As a result, the KG remains a single, consistent source of truth for the entire architecture, while other agents and modules can rely on a stable service that mediates all interactions with the underlying knowledge base.

IV. IMPLEMENTATION.

This section presents the core algorithmic components and theoretical foundations underlying the system’s imple-mentation, focusing on the computational mechanisms that enable transparency, traceability, and human-centered decision-making. Figure 3 provides an overview of the interconnections between the algorithmic schemes relevant to our technical solution, towards further supporting the understanding of the computational mechanisms applied.

A. KNOWLEDGE GRAPH STORAGE AND PROVENANCE

The KG is implemented using RDFLib’s in-memory Graph structure, where facts are represented as RDF triples with URIRef objects for subjects and predicates, and Literal objects for values. The choice of RDF as the underlying representation formalism provides standardized seman-tics, while enabling explicit provenance tracking through reification-like structures over fact identifiers rather than direct triple reification.

Each fact is assigned a unique identifier factid = f“{subject}|{predicate}| {normalizedobject}” which is URI-encoded and stored as a separate URIRef. This identifier acts as a stable anchor for attaching provenance. The overall fact storage pipeline, including the creation of fact identifiers and attachment of provenance metadata, is summarized in Algorithm 1. In this abstraction, the storage procedure assumes that entities have already been normalized to a canonical form (cf. Algorithm 2 and Algorithm 3).

Algorithm 1 Fact Storage With Provenance Metadata Require: raw entity e, predicate p, value v, source document s, timestamp t, agent identifier a, confidence score c, knowledge graph G Ensure: updated knowledge graph G′ 1: ̃e ← NormalizeEntity(e) 2: us ← urn:entity:∥encode(̃e) 3: up ← urn:predicate:∥encode(p) 4: insert triple (us, up, v) into G 5: f ← urn:fact:∥encode(̃e, p, v) 6: insert provenance triples (f, sourcedocument, s), (f, uploadedat, t), (f, agentid, a), (f, confidence, c) into G 7: return G′

Provenance metadata (source document, ingestion times-tamp, agent identifier, and confidence) is, thus, attached via additional triples that link factIDURI nodes to their corresponding metadata values (lines 8–11 in Algorithm 1). This design allows multiple sources to be associated with the same logical fact and maintains complete auditability of how each fact entered the graph and under which conditions (agent and confidence). Graph persistence follows a dual-format strategy: binary pickle serialization is used for efficient loading during system startup, while a JSON backup provides portability and inspectability. This separation of concerns allows the system to remain operationally efficient without sacrificing transparency or interoperability.

1) ENTITY NORMALIZATION.

Entity normalization addresses the representational consis-tency problem: semantically identical entities with different surface forms (e.g. “John Smith”, “johnsmith”, “John Smith”) must map to a shared canonical represen-tation to avoid fragmentation in the KG. Algorithm 2 for-malizes the normalization procedure applied before storage in Algorithm 1.

To move beyond static, hand-crafted mappings, the system learns normalization mappings from existing facts in the

Algorithm 2 Entity Normalization Procedure Algorithm 3 Learning Normalization Mappings From Stored Facts Require: raw entity e, normalization map M Require: knowledge graph G, normalization map M Ensure: canonical normalized entity ̃e Ensure: updated normalization map M ′ 1: n ← lowercaseandtrim(e) 1: Initialize grouping dictionary C ←∅ 2: n ← removespecialcharacters(n) 2: for all triples (s, p, o) ∈ G do 3: n ← collapsemultiplespaces(n) k ← lowercaseandtrim(s) 3: 4: if n ∈ dom(M) then append s to C [k ] 4: ̃e ← M [n] 5: 5: end for 6: else 6: for all keys k ∈ C do ̃e ← n 7: 0 ← distinct variants in C [k ] 7: 8: end if if |0| > 1 then 8: 9: return ̃e γ ⋆ ← most frequent element in 0 9: for all γ ∈ 0 do 10: if lowercase(γ)̸ = lowercase(γ ⋆) then 11: M [lowercase(γ)] ← lowercase(γ ⋆) graph.

Intuitively, surface forms that collapse to the same 12: normalized key are grouped together, and the most frequent end if 13: variant in each group is treated as canonical. The procedure end for 14: is given in Algorithm 3; it is periodically executed to refine end if 15: the normalization map M as the graph grows. Through 16: end for Algorithm 2 and Algorithm 3, entity references in incoming 17: return M ′ facts are progressively canonicalised, reducing duplication and improving the reliability of downstream reasoning over the graph.

2) DUPLICATE PREVENTION.

Duplicate prevention is critical for both correctness and efficiency, especially under parallel processing. The system maintains an in-memory hash set factlookupset containing normalized fact tuples, typically of the form (̃e, p, v) after entity normalization. This index is initialized at startup by a single pass over the persisted graph (an O(n) operation in the number of stored facts) and is maintained incrementally during operation. Before executing the insertion step on Algorithm 1 (line 5), the system performs a O membership check against factlookupset. Only if the fact is not present is it added both to the graph and to the index. This design ensures that concurrent worker threads can safely check for duplicates without requiring expensive graph traversal, while preserving the integrity and uniqueness of stored facts.

B. MULTI-AGENT ORCHESTRATION

The multi-agent system implements indirect coordination through the shared KG, eliminating the need for explicit point-to-point message passing between agents. Each agent is implemented as a Python dataclass with identity attributes, lifecycle status, and configuration metadata. Rather than exchanging messages, agents interact by reading from and writing to the KG: worker agents inject data-derived facts, while analytical agents augment the graph with higher-level semantic structure. This design yields a naturally decoupled architecture in which agents can be added, removed, or reconfigured without changing the communication protocol.

Worker agents operate on document chunks, extract structured information, and invoke the fact storage pipeline (Algorithm 1) to insert provenance-enriched triples into the graph. Analytical agents (Statistics and Operational) run periodically or on demand, consume existing graph-backed tabular data (e.g. data frames reconstructed from source documents), compute derived metrics, and write results back as facts on the same representational substrate. The result is a unified interface in which both raw data and derived patterns can be queryable through the same graph-based abstraction.

The Statistics Agent focuses on correlation analysis and descriptive statistics over numeric attributes. Conceptually, it identifies numeric columns, computes pairwise corre-lations, filters them based on a configurable magnitude threshold, and then stores statistically salient relationships as facts. In addition, it computes basic descriptive statistics (mean, median, standard deviation, minimum, maximum) for each numeric attribute and records them as separate facts. The overall procedure is summarized in Algorithm 4.

Algorithm 4 Statistics Agent: Correlations and Descriptive Metrics

Require: data frame D, source document identifier s Ensure: statistical facts stored in graph G 1: N ← numeric columns of D 2: R ← correlation matrix over N 3: τ ← 0.3 4: for all pairs (ci, cj) of columns in N with i < j do r ← R[ci, cj] 5: if |r | > τ then 6: ADDFACTWITHPROVENANCE 7: (correlationcicj, hascorrelationvalue, r, s) end if 8: 9: end for 10: for all columns c ∈ N do compute μ, ̃m, σ, mmin, mmax for c 11: (n, v) for all pairs ∈ 12: {(mean, μ), (median, ̃m), (std, σ), (mmin, mmax)} do ADDFACTWITHPROVENANCE(c, hasn, v, s) 13: end for 14: 15: end for

Here, AddFactWithProvenance denotes the fact inser-tion routine of Algorithm 1, which normalizes entities, constructs fact identifiers, and attaches provenance meta-data. By encoding statistical relationships (e.g. salary hasmean 75000) as graph facts, downstream agents and user-facing services can query high-level summaries using the same mechanism as for atomic data.

The Operational Agent is responsible for generating business-oriented insights, primarily via grouped aggre-gations over organizational dimensions such as depart-ment and manager. Its logic can be framed as a set of group-by operations that compute aggregated salary and performance metrics, which are then materialized as facts. These operational facts support queries such as ‘‘What is the average salary by department?’’ or ‘‘Which manager oversees the highest average performance?’’ without recomputing aggregations at query time. Algorithm 5 summarizes the procedure.

Algorithm 5 Operational Agent: Department- and Manager-Level Insights

Require: data frame D, source document identifier s

Ensure: operational facts stored in graph G 1: if department and salary are columns in D then compute department-level table Tdept 2: for all rows r ∈ Tdept do 3:

ADDFACTWITHPROVENANCE(r [department], 4: hasaveragesalary, r [meansalary], s) ADDFACTWITHPROVENANCE(r [department], 5: hasemployeecount, r [employeecount], s) end for 6: 7: end if 8: if manager is a column in D then compute manager-level table Tmgr 9: for all rows r ∈ Tmgr do 10: if meansalary exists in r then 11: ADDFACTWITHPROVENANCE(r [manager], 12: managesavgsalary, r [meansalary], s) end if 13: if meanperformance exists in r then 14:

ADDFACTWITHPROVENANCE(r [manager], 15: managesavgperformance, r [meanperformance], s) end if 16: end for 17: 18: end if

Both Algorithm 4 and Algorithm 5 follow the same interaction pattern with the rest of the architecture: they consume tabular views derived from uploaded HR docu-ments, compute domain-specific metrics, and project the results back into the KG using the provenance-aware storage pipeline of Algorithm 1. Because all outputs are expressed as RDF facts, higher-level multi-agent orchestration (e.g. the Orchestrator and Operational Query Agents) can answer complex analytical questions by chaining graph queries rather than directly invoking individual agents. This preserves loose coupling between agents while ensuring that the emergent behavioral semantics of the system remain fully inspectable through the graph.

C. QUERY ROUTING AND CLASSIFICATION

Query routing is implemented as a hierarchical pattern-matching procedure that processes incoming queries through a sequence of priority-ordered stages. The primary motiva-tion is computational efficiency and selectivity: employee-specific queries can often be answered by contacting only the subset of document agents that host the relevant records, thereby reducing unnecessary graph traversal and agent activation. At the same time, the router is designed to remain transparent by returning structured routing decisions that explicitly encode both the selected strategy and the underlying rationale. A conceptual representation of the algorithmic applied for implementing the routing protocol is presented in Figure 4.

The routing policy operates over two main inputs: the free-text query q and an externally assigned query type τ (e.g. “filter”, “operational”, “structured”). Internally, the router maintains keyword lists and regular-expression patterns associated with different classes of analytical intent (statistical, operational, or general conversa-tional queries). The overall decision procedure is summarized in Algorithm 6, which abstracts the Python implementation given in the code list.

As shown in Algorithm 6, the router first attempts to detect highly specific employee-level queries (Stage 1). When the query type τ is “filter”, a regular-expression pattern is applied to the raw query text to identify name mentions of the form “Surname, Firstname”. If a match is found, the procedure FindAgentsForEmployee returns the subset of document agents that host records for the identified employee. In this case, the routing strategy is updated to “specificagents”, the corresponding agent identifiers are recorded in R.targetagents and the remaining stages are skipped. Therefore, this short-circuit behavior allows the system to handle employee-specific filters by querying only the relevant agents (instead of querying the entire multi-agent population).

If no employee-specific match is found, the router proceeds to intent classification based on lexical cues and query type. Statistical intent (Stage 2) is detected by scanning the lowercased query text qlower for the presence of any keyword in the statistical keyword set Kstat. Queries that fall into this category are routed exclu-sively to the Statistics Agent (Algorithm 4), as indicated by setting R.strategy “statisticsagent” and = R.targetagents [“statisticsagent”]. Opera-= tional queries (Stage 3) are identified through the externally assigned type “operational” and dispatched to the Operational Query Agent (Algorithm 5). Structured queries (Stage 4), such as max/min or filter-style requests over clearly defined attributes, are handled via the “directlookup” strategy, which bypasses analytical agents and answers the query through direct graph retrieval.

Finally, queries that do not match any of the above stages fall back to a conversational strategy (Stage 5) and are routed to the LLM Agent. At each exit point, the router populates the reason field of the routing decision R with a human-readable explanation (e.g. ‘‘Query requires statistical analysis’’ or ‘‘Routed to operational agent’’). Combined with the explicit strategy and targetagents fields, this design makes the internal routing logic inspectable and provides end users with a clear account of why a particular query was classified in a given way and which agents were selected to process it.

D. PARALLEL PROCESSING AND CONCURRENCY

Parallel document processing is implemented using Python’s combined with an adaptive ThreadPoolExecutor chunking strategy. Given a tabular dataset represented as a pandas DataFrame, the system computes a chunk size as chunksize = max(25, min(200, ⌊15000/C ⌋)), where C is the number of columns. This heuristic targets approximately 15,000 data points per chunk while enforcing

Algorithm 6 Query Router for Agent Selection Require: query string q Require: query type τ Ensure: routing decision R 1: R.strategy ← all-agents 2: R.targetAgents ← [ ] 3: R.reason ← "" 4: ql ← lowercase(q) 5: Stage 1: Employee-specific detection 6: if τ = filter then define name pattern π 7: match ← regexSearch(π, q) 8: if match exists then 9: employeeName ← extractGroup(match) 10: A ← FindAgentsForEmployee(employeeName) 11: if A̸ = ∅ then 12: R.strategy ← specific-agents 13: R.targetAgents ← A 14: R.reason ← 15: "Found employee in matching agent(s)" return R 16: end if 17: end if 18: 19: end if 20: Stage 2: Statistical query detection 21: define keyword set Kstat 22: if ∃k ∈ Kstat: k ∈ ql then R.strategy ← statistics-agent 23: R.targetAgents ← [statistics-agent] 24: R.reason ← "Query requires stat. analysis 25: " return R 26: 27: end if 28: Stage 3: Operational query detection 29: if τ = operational then R.strategy ← operational-agent 30: R.targetAgents ← [operational-query-agent] 31: R.reason ← "Routed to operational agent" 32: return R 33: 34: end if 35: Stage 4: Structured pattern matching 36: if τ = structured then R.strategy ← direct-lookup 37: R.reason ← "Structured query: use direct 38: graph lookup" return R 39: 40: end if 41: Stage 5: Conversational fallback 42: R.strategy ← llm-agent 43: R.targetAgents ← [llm-agent] 44: R.reason ← "Default: conversational query" 45: return R lower and upper bounds on the chunk size.

As a result, load is balanced across workers without creating excessively small chunks (which would incur overhead) or overly large chunks (which would undermine parallelization). This adaptive approach ensures efficient utilization of worker threads across datasets with heterogeneous dimensions.

The parallel extraction pipeline (Algorithm 7) partitions the DataFrame into non-overlapping row ranges, submits one task per chunk to the thread pool, and aggregates the number of facts added by all workers. Each worker thread executes a dedicated chunk-processing routine that iterates over its assigned rows, constructs candidate facts, performs a O duplicate check against the in-memory fact index, and, if the fact is new, invokes the provenance-aware storage routine (Algorithm 1). A thread-local counter tracks the number of facts added per chunk and is merged into a shared counter using a lightweight lock.

The theoretical foundation for this design is that RDFLib’s graph operations are thread-safe in this setting, allowing concurrent writes to the shared KG without explicit synchro-nization primitives. Consequently, threading.Lock is required only for updating shared counters and registries, not for graph access itself. This keeps contention low and preserves scalability as the number of worker threads increases.

The chunking algorithm ensures complete coverage of the input by partitioning the row index range [0, R) into contiguous, non-overlapping intervals and processing each interval exactly once. Since each chunk operates on a disjoint subset of rows and duplicate detection is performed through an O hash-based index (for example, an in-memory fact set), the system avoids both redundant work and incon-sistent fact insertion. In practice, the architecture achieves near-linear speedups for large documents as the number of worker threads increases, while preserving data consistency through thread-safe graph operations and narrowly scoped locking only around shared counters.

E. EVIDENCE ASSEMBLY AND FACT RANKING

Evidence assembly is responsible for selecting and presenting the most relevant facts from the KG in response to a given query. Rather than returning an unstructured list of all matching facts, the system applies a relevance-based ranking function that takes into account keyword overlap, entity name matches, and predicate alignment. The top-k facts (typically k = 5) are then formatted with explicit source attribution, ensuring that every system response is grounded in inspectable, human-readable evidence.

Given a set of candidate evidence facts, each represented as a structured record containing subject, predicate, object, and optional source metadata, the evidence assembly component performs two main steps. First, it ranks facts by a relevance score derived from semantic overlap between the query text and the concatenation of subject, predicate, and object (Algorithm 8). Second, it constructs an evidence context string by selecting the top-k facts, numbering them, and appending at most a small number of distinct sources per fact (Algorithm 9). This design supports explainability by making the evidence artefacts explicit, while also reducing cognitive load by ordering them from most to least informative.

Algorithm 8 defines a simple yet effective relevance scoring scheme. Keyword overlap between the query and the

Algorithm 7 Parallel Fact Extraction With ThreadPoolEx-ecutor Require: Data frame D, document identifier s, number of workers W Ensure: Total number of newly added facts 1: R ← number of rows in D 2: C ← number of columns in D 3: chunksize ← max(25, min(200, ⌊15000/C ⌋)) 4: Initialize list of chunks C ← [ ] 5: for start ← 0 to R − 1step chunksize do end ← min(start + chunksize, R) 6: Append interval (start, end) to C 7: 8: end for 9: Initialize shared counter factsadded ← 0 10: Initialize lock L for synchronising counter updates ▷ Worker routine for a single chunk 11: 12: function PROCESSCHUNK(i, start, end) Extract sub-frame Di ← D[start: end] 13: localfacts ← 0 14: for all rows r in Di do 15: employeename ← r [“EmployeeName”] 16: for all columns in with c Di c = 17: “EmployeeName” do fact ← (employeename, 18: “has”∥lowercase(c), r [c]) if FACTEXISTS(fact) is false then 19: ADDFACTWITHPROVENANCE 20: (fact, s, “worker”∥i) localfacts ← localfacts + 1 21: end if 22: end for 23: end for 24: Acquire lock L 25: factsadded ← factsadded + localfacts 26: Release lock L 27: return localfacts 28: 29: end function

▷ Submit all chunks to the thread pool 30: 31: Create thread pool with W workers 32: for all chunks (start, end) in C with index i do

Submit PROCESSCHUNK(i, start, end) to thread pool 33: 34: end for 35: Wait for all tasks to complete, handling any exceptions 36: return factsadded fact text is weighted most heavily, entity name matches in the subject receive an additional bonus, and predicate alignment contributes a smaller increment. This reflects the intuition that a fact is especially relevant when it mentions the same entities and relationships as the query itself.

Once facts have been ranked, the evidence assembly component constructs a textual evidence context to be

Algorithm 8 Fact Relevance Ranking has fields f.subject, Require: set of facts F (each f f.predicate, f.object), query string q Ensure: facts sorted by decreasing relevance, Franked 1: Q ← Tokenize(lowercase(q)) 2: function SCOREFACT(f) x ← lowercase(f.subject∥f.predicate∥f.object) 3: T ← Tokenize(x) 4: score ← 0 5: ▷ Keyword overlap score ← score + 2 · |Q ∩ T | 6: ▷ Subject substring match if ∃t ∈ Q: t ⊆ lowercase(f.subject) then 7: score ← score + 3 8: end if 9: ▷ Predicate substring match if ∃t ∈ Q: t ⊆ lowercase(f.predicate) then 10: score ← score + 1 11: end if 12: return score 13: 14: end function 15: Franked ← SortDescending(F, f 7→ SCOREFACT(f)) 16: return Franked attached to the system’s answer.

This context is a numbered list of the top-k facts, each optionally annotated with a compact list of sources indicating where in the underlying data the fact originated (e.g. document names). The procedure is summarized in Algorithm 9.

The theoretical foundation of this component is that explainability requires not only the presence of evidence but also its prioritization. By ranking facts according to semantic overlap with the query and presenting the most relevant ones first, the system provides a focused, yet transparent view of the underlying knowledge used to support each answer. Users can quickly inspect the most informative supporting facts without being overwhelmed by all possible matches, while full traceability is retained through explicit source attribution for each fact in the evidence list.

V. RESULTS AND PERFORMANCE ANALYSIS.

This section demonstrates all key system features through a realistic HR scenario, which can be further observed in our demo available in the linked source. In more detail, it starts with a presentation of the scenario-based evaluation approach followed to test our system’s performance and compare it against baselines. Then, it analyzes the properties of interest together with the relevant metrics. Finally, it presents the performance of our system in these metrics.

A. SCENARIO-BASED EVALUATION

The scenario-based performance analysis is designed to assess the system’s ability to detect and exploit relationships

Algorithm 9 Evidence Assembly From Ranked Facts Require: Ranked list of facts Franked, query string q, top-k parameter k Ensure: Evidence context string E 1: if Franked is empty then return empty string 2: 3: end if 4: Fk ← first k elements of Franked Initialize list of lines ← L 5: [“Evidence from KG:”] 6: i ← 1 7: for all facts f in Fk do subj ← f.subject 8: pred ← f.predicate 9: obj ← f.object 10: sources ← f.source (if present, else empty list) 11: line ← formatted string “i. subj → pred → 12: obj” if sources is not empty then 13: Extract a list of stringified source identifiers from 14: sources Remove duplicates while preserving order 15: Keep at most two distinct sources 16: Append formatted source list to line as 17: “[Source: s1, s2]” end if 18: Append line to L 19: i ← i + 1 20: 21: end for 22: E ← join all elements of L with newline separators 23: return E among multiple HR-related variables under varying levels of combinatorial complexity.

We start from a data set for HR analytics that contains R employee records and N variables. For experimentation purposes, we rely on a public HR dataset from Kaggle,1 which in our case comprises R = 311 employees and N = 36 variables (including, among others, Salary, Department, Manager Name, Recruitment Source, Performance Score, Engagement Survey, Special Projects Count, and Absences). This dataset provides a sufficiently rich space of potential multi-variable relationships to stress-test the decision-support capabilities of the proposed system.

We construct evaluation scenarios by considering subsets of the N variables of different cardinalities. Formally, for a fixed subset size k ∈{2, 3... }, the number of distinct k -way combinations that can be formed from N variables is given by the binomial coefficient

N  N! k! (N − k)!. |Ck | = = k 1Retrieved from: the linked source

In principle, if we consider all combinations from pairs up to a maximum order Kmax, the total number of potential multi-variable scenarios is

Kmax N  X

=

C≤Kmax. k k =2

In this work, we focus primarily on 2-variable (2 × 2) com-binations, which correspond most naturally to operational HR queries. For the concrete dataset with N = 36 variables, the number of possible 2-variable combinations is which defines an upper bound on the space of potential operational scenarios that could, in principle, be posed by HR stakeholders as pairwise monitoring or diagnostic queries (e.g., Department, × SpecialProjectsCount Absences × Manager). While Equation characterizes the full pairwise space, in practice we instantiate a curated subset of operational scenarios, guided by a predefined library of query templates.

The query template library is divided into operational, strategic, and evidence retrieval levels. Operational-level templates concentrate on 2-variable combinations such as PerformanceScore – Department, Absences – EmploymentStatus, and EngagementSurvey – ManagerName, each with one or more instantiated natural-language questions (e.g., departmental performance monitoring, absence patterns by manager, team-level engagement monitoring). Strategic-level templates capture 3-variable combinations (e.g., PerformanceScore -– SpecialProjectsCount, EngagementSurvey PerformanceScore – Satisfaction – Absences), instantiated as higher-level queries about risk clusters. Evidence retrieval-level templates include questions related with IR, requesting for facts or information regarding employees.

These templates are specified in a separate query template file, presented in Appendix, and provide the basis for generating natural-language scenarios used in the evaluation.

Each scenario corresponds to a specific subset of variables and an associated natural-language query that an HR stakeholder might pose (e.g., ‘‘What is the distribution of per-formance scores by department?’’, ‘‘How does performance vary by recruitment source??’’, ‘‘Find employees with high performance, low engagement and low satisfaction.’’). Our system, which is intended as a generic decision-support layer on top of HR data, is evaluated in terms of its accuracy in recovering the correct relationships and providing sufficient information for each scenario.

B. PROPERTY-BASED PERFORMANCE EVALUATION

This part of the results focuses on the evaluation of the proposed system in terms of properties of interest for HR professionals. Therefore, it presents the properties and metrics for the evaluation, the methodology for the systematic assessment of the system, and the results in terms of the metrics described.

Our evaluation focuses on six dimensions that opera-tionalize key pillars of explainability identified in recent requirements-engineering work. We build on a user-centered quality model proposed in the literature, which organizes explainability into aspects such as understandability, trans-parency, effectiveness, efficiency, satisfaction and correct-ness, with associated criteria and metrics. We also rely on the requirements-oriented perspective of, where transparency, explainability and traceability are treated as interrelated quality requirements. The following metrics specify, for each dimension, what data is collected and how the numerical scores are computed.

1) ACCURACY AND RELIABILITY OF FACT RETRIEVAL.

For each evaluation query q, we define a query-dependent reference set of required facts Gq, derived from the query semantics and the underlying HR dataset and KG. When answering q, the system returns a set of retrieved evidence facts Rq (subject–predicate–object triples with provenance), which are compared against Gq to assess retrieval adequacy.

Using these two sets, we compute the harmonic mean F1, which jointly summarizes precision and recall, as defined in Equation 4:

F1(q) = 2 · Precision(q) · Recall(q) Precision(q) + Recall(q),

2) TRACEABILITY COMPLETENESS.

Traceability captures the extent to which answers can be traced back to underlying data, in line with transparency and traceability requirements. For each query q, domain experts identify the set Dq of data items (rows, cells, or facts) that legitimately support the answer. The system, in turn, presents a subset of these items as explicit evidence (e.g. in an ‘‘Evidence’’ panel), which we denote as Tq ⊆ Dq. Traceability completeness is simply the proportion of relevant data items that are made visible:

In addition, we record how many correctly linked evidence items are shown per answer sentence, which provides a density-style view of how tightly the textual explanation is anchored in concrete facts.

3) HALLUCINATION RESISTANCE.

Hallucination resistance measures how rarely the system introduces claims that are not supported by the KG or the underlying dataset. For each answer, annotators decompose the text into atomic claims and, for each claim, check whether it can be justified by existing facts or by direct computation from the data. Let Cq be the number of claims in the answer to query q, and Hq the number of claims labelled as hallucinated (unsupported). The hallucination rate and its complement are then

HallucinationRate(q) = Hq, Cq

HallucinationResistance(q) = 1 − HallucinationRate(q).

Scores are averaged over all queries. This metric links to the correctness and trustability aspects, as a low halluci-nation rate is essential for users to rely on the system’s explanations.

4) RESPONSE LATENCY.

Response latency operationalizes the efficiency aspect of explainability: explanations should arrive quickly enough to be useful in interactive decision-making. For each query q, we instrument the system to record the time stamp in user submission and the time stamp when the complete answer (including evidence) is rendered. Their difference is the end-to-end response time tq. Over all queries Q, we compute the mean latency t = 1 X tq, |Q| q∈Q and report t together with its 95% confidence interval. In user studies, we additionally measure how long participants take to complete each decision-making task with and without the tool; comparing these task times indicates whether explanations speed up or slow down human work.

5) QUERY-LEVEL ACCURACY.

While precision, recall, and F1 assess fact-level correctness, we additionally report a coarse-grained query-level accuracy that reflects whether the system produces an overall correct answer for a given query. For each evaluation query q, annotators determine whether the returned answer is correct as a whole, i.e. whether it correctly addresses the intent of the query without missing or incorrect conclusions. Let Aq ∈{0, 1} be a binary indicator, where Aq = 1 if the answer to q is judged correct and Aq = 0 otherwise. Over the full set of queries Q, query-level accuracy is defined as

Accuracy = 1 X Aq. |Q| q∈Q

This metric provides an intuitive, user-oriented view of system performance, capturing the proportion of queries for which users would receive a fully satisfactory answer. We therefore report accuracy alongside fact-level metrics to bridge fine-grained correctness with holistic task success.

The results in Table 1, also summarized in Table 2, show a clear differentiation in system performance across operational, strategic, and evidence-retrieval query cate-gories. Operational queries are handled robustly: the majority achieve perfect F1, traceability completeness, hallucination resistance, and accuracy, with consistently low response latency (typically below 0.01 s). This indicates that for structured, well-defined analytical tasks–such as aggrega-tions, comparisons, and factual lookups–the system reliably retrieves correct results and exposes the full supporting evidence, thereby satisfying both correctness and trans-parency requirements.

The few operational failures (e.g. O2.x) correspond to cases where the underlying computation or retrieval could not be completed correctly; importantly, these failures are reflected consistently across all metrics (low F1, zero accuracy, and zero traceability), suggesting conservative behavior rather than spurious or misleading outputs.

A potential source of misinterpretation concerns a small subset of operational queries (e.g. O1.3), for which F1 = 0 and traceability is zero while query-level accuracy is 1.0. This pattern reflects the fact that the metrics capture different aspects of performance. Query-level accuracy evalu-ates whether the final answer is correct, whereas F1 evaluates whether the expected supporting facts are retrieved from the KG. For some aggregation-based queries, the system computes the correct answer directly from the structured CSV data, but no explicit KG facts are retrieved or matched against the reference fact set. Therefore, F1 = 0 with accuracy = 1.0 should be interpreted as a conservative evidence-retrieval score, not as a reporting or system error.

The consistently low latency reported in these categories warrants clarification. The measured values correspond to end-to-end query execution time–from query submission to complete response delivery–and include query parsing, intent extraction, local KG traversal, CSV loading and aggregation (where applicable), and response formatting. Crucially, no external LLM is invoked at query time. While the architecture incorporates an LLM component, its role is confined to offline document processing during ingestion (e.g. schema extraction and normalisation). As a result, operational and evidence-retrieval queries are executed entirely through in-memory KG lookups and local CSV computations, explaining the sub-second latency observed.

Strategic queries, which involve multi-variable filtering and combined KG–CSV reasoning, exhibit higher but still bounded response times, reflecting their increased compu-tational complexity rather than any generative overhead. All latency measurements were obtained on a local machine with the KG stored in memory and CSV data loaded from disk; while absolute timings are hardware-dependent, the relative differences across query types are reproducible.

In contrast, strategic queries (S1.x–S2.1) exhibit uniformly low performance across all metrics. These queries typically require higher-level synthesis, abstraction, or policy-oriented reasoning that goes beyond direct aggregation or retrieval from the underlying dataset. The system correctly fails these cases, producing low accuracy and traceability rather than unsupported or hallucinated answers. This behavior aligns with the design goal of avoiding over-confident responses in underspecified or analytically complex scenarios. Finally, evidence-retrieval queries (A-series) demonstrate strong performance, with high F1, perfect hallucination resistance, and full traceability in most cases. Even where partial correctness is observed (A1.2), the system still exposes relevant evidence and maintains correctness at the query level.

All these results indicate that the tool is highly reliable for operational analytics and evidence-grounded explanations, while remaining appropriately cautious for strategic reasoning tasks that require broader contextual or normative interpretation.

VI. HOW DOES THE SYSTEM PERFORM AGAINST API-BASED BASELINES? A BENCHMARKING PROTOCOL AND CORRESPONDING RESULTS

One of the main issues regarding the broad adoption of API-based LLMs is that, in many cases, they are not comparable with in-house tools in a one-to-one manner. In any way, this angle is of importance especially in the case of HRM. By following the significant gaps identified in the work of in this vein, our work first introduces an analytical rigorous protocol for benchmarking in specific instances related to explainability and then applies the framework to present some evidence regarding our tool’s performance in contrast to well-known, API-based LLMs. Specifically, to benchmark the performance, we compare the system’s outputs against answers generated by a set of three API-based LLMs:

• OpenAI GPT-5.2 (Chat Completions API),

• Google Gemini 1.5 Pro (Gemini API),

• xAI Grok (API-based access).

At this stage, it is important to note that the primary advantage of our model lies in its ability to produce fact-grounded responses. Because this capability is enabled by the underlying knowledge base (constructed from the developed KG), it cannot be meaningfully assessed against API-based LLM tools that are trained as multi-modal, case-agnostic token predictors. To ensure a fair and strict comparison, we therefore adopt a qualitative, human-centered benchmark-ing design (rather than a purely quantitative one), following established best-practice guidance for human evaluation of NLG systems. The proposed qualitative protocol comprises three phases. Phase 1 develops user-centric scenarios grounded in the variables of the original dataset, emphasizing realistic combinations that are likely to occur in practice and that map to either operational or strategic high-level queries.

Phase 2 is expert-driven: domain experts (two persons) working at the intersection of HRM and AI identify, through open voting, which mathematically feasible combinations are most plausible and most likely to be asked frequently. Phase 3 implements a controlled human assessment: two researchers independently run the resulting queries and rate answer quality on a five-point scale.

Concretely, the five-point ratings were anchored on three criteria: (i) factual groundedness (e.g., whether claims are supported by entities/relations available in the KG and do not introduce unsupported information), (ii) intent- and context-relevance (e.g., whether the response directly addresses the operational/strategic intent of the query rather than providing generic background), and (iii) utility and clarity (e.g., whether the response is sufficiently complete and actionable for decision-making, and is stated unambiguously). This proce-dure was designed to safeguard fairness because the quality of answers produced by API-based LLMs may vary across users and prompts due to instruction tuning and reinforcement learning from human feedback (RLHF).

In addition, emerging research shows that LLMs have unstable beliefs under extended use and their stated beliefs (even their behavior) systematically drift as context accumulates. In what follows, we detail the mathematical foundations and assumptions governing the proposed benchmarking protocol.

For executing our setting, the API-based LLMs were pro-vided with the relevant HR dataset context (e.g., tables con-taining the variables referenced in the corresponding query) prior to answer generation. The evaluation corpus was con-structed using the publicly available HRDataset v14 dataset, comprising 311 employee records and 36 HR-related variables, including employee demographics, departmental affiliation, recruitment source, performance indicators, engagement metrics, salary information, absences, man-agerial structure, and special project participation. This setting evaluates the ability of the API-based models to perform data-grounded analytical reasoning when the same information available to the proposed framework is explicitly supplied as contextual evidence.

To ensure methodological consistency and reproducibil-ity, all API-based LLMs were evaluated under the same controlled experimental setting. Each model received the same natural-language query together with the same relevant dataset-derived contextual information required to answer the corresponding scenario. The prompts explicitly instructed the models to answer exclusively on the basis of the provided dataset context and to avoid unsupported assumptions, hallucinated facts, or externally inferred information.

To mitigate stochastic variability in API-based generation, each query was executed independently five times per evaluated model. Let Rm,q = r1, r2..., r5 denote the set of responses generated by model m for query q. The final representative response ˆrm,q was selected using a majority-consensus strategy: freq(r), ˆrm,q = arg max r ∈Rm,q where freq(r) denotes the number of semantically equivalent occurrences of response r across the five executions. This procedure was adopted to reduce the effect of response variability and improve the stability of the qualitative assessment.

The generated responses were independently assessed by two researchers using the same predefined qualitative criteria: (i) factual groundedness, (ii) intent- and context-relevance, and (iii) utility and clarity. Factual groundedness evaluated whether the generated claims were directly supported by the provided dataset evidence; intent- and context-relevance assessed whether the response correctly addressed the analytical objective of the query; and utility/clarity evaluated whether the produced answer was coherent, interpretable, and practically useful for HR-oriented decision support. In cases of disagreement, the evaluators followed an iterative recon-ciliation procedure involving score comparison, justification of the assigned ratings, and consensus-based discussion until a final agreed assessment was reached.

From an HR decision-making perspective, scenarios differ not only in combinatorial size but also in their managerial role. In alignment with our focus on the 2 × 2 combinations, we treat scenarios with k = 2 as operational, reflecting day-to-day monitoring and diagnosis, while scenarios with k ≥ 3 are treated as strategic, reflecting more complex, high-level questions about workforce structure and policy.

To justify this distinction, we model the intrinsic com-plexity of a k -variable scenario via the number of potential pairwise interactions among the k variables. For a subset of size k, the number of pairwise relationships is

k  = k (k − 1). E (k) = 2 2

We assume that there exists an upper bound Emax on the cognitive and organizational capacity to treat a scenario as operational; beyond this bound, scenarios are better understood as strategic. Formally, we define the cut-off order k ∗ as k ∗ = max {k ∈ N | E (k) ≤ Emax}, that is, the largest scenario size for which the number of pairwise interactions does not exceed Emax. Using Equation, the inequality E (k) ≤ Emax becomes k (k − 1) ≤ Emax, 2 which yields the quadratic condition k ≤ 1 + √1 + 8Emax. 2

In our experimental design, we instantiate Emax so that k ∗ = 2, i.e., we deliberately constrain the operational regime to pairwise scenarios. This is achieved by choosing Emax such that

E = 1 ≤ Emax < E = 3, for example Emax = 2, which via Equation yields

√ $ % $ % 1 + 1 + 8 · 2 1 + 17 k ∗ = = 2. = 2 2

Under this lens, we classify scenarios as Operational when k = 2, and as Strategic when k ≥ 3. This choice aligns the mathematical formulation of complexity with our empirical focus on 2-variable operational queries (Equation ) and 3-variable strategic templates. It also reflects the intuition that the number of potential interactions increases quadratically with k (Equation ), and that moving from k = 2 to k = 3 already induces a substantial increase in interpretive complexity for HR stakeholders. As mentioned in the previ-ous subsection, the possible 2 × 2 combinatorial schemes, equal to 630 for our case. Following the documentation provided, this number corresponds to the possible operational scenarios that might be evaluated by an HR specialist.

After assessing the relevance of these queries under the lens of HR requirements and for safeguarding the alignment with the corpus included for the evaluation of the tools, we have decided to include the same queries as previously, but exclud-ing the queries associated with facts retrieval. This leads to the development of a final corpus encompassing 24 benchmark queries in total (corresponding to the ranges O1.1–O1.4, O2.1–O2.4, O3.1–O3.3, O4.1–O4.3, O5.1–O5.3, S1.1–S1.4, and S2.1–S2.3 of the queries included in Appendix). This corpus was deliberately selected to evaluate the behavior of the API-based models under both operational and strategic HR analytics scenarios.

The resulting qualitative scores are summarized in Figure Figure 5, while Table Table 3 presents two representative examples illustrating how the proposed evaluation protocol translates concrete response traces into groundedness, relevance, and utility assessments.

The two representative benchmark queries in Table 3 map directly onto the coding scheme of Figure 5: the first prompt corresponds to Query O1.1 and is classified as Operational because it instantiates a 2 × 2 combination (performance × department), whereas the second prompt corresponds to Query S2.1 and is classified as Strategic because it requires reasoning over three variables or more (salary × performance × department). These concrete response traces are then translated into the qualitative scores in Figure 5 by applying the axis-specific criteria at the appropriate granularity.

For O1.1, factual groundedness is driven by whether the tool reports department-level performance using the correct numeric scale and values: GPT-5.2 and Gemini 1.5 reproduce the department averages and therefore receive mid-to-high grounding and context relevance, while Grok changes the measurement represen-tation to categorical ratings (‘‘Exceeds/Fully Meets/Needs Improvement/PIP’’) and introduces unsupported distribution statements (e.g., a large departmental share), which materi-ally reduces grounding even if the prose remains readable.

Utility & clarity is scored separately from grounding: GPT-5.2 is rewarded for an interpretable narrative summary, Gemini 1.5 for a concise tabulation, and Grok for fluent presentation, but these gains do not compensate for a mismatch between the requested operational aggregation and the response content, which is reflected in lower groundedness than utility for Grok in O1.1.

For S2.1, the scoring reflects the higher evidentiary bar associated with Strategic queries: GPT-5.2 provides a plausible cross-variable narrative but without explicit dataset-backed evidence at the department-conditioned level (hence moderate groundedness and relevance), Gemini 1.5 reports a single global correlation without department-stratified interpretation (lower context relevance and utility for a department-conditioned, three-variable query) and without guidance toward an explicitly correlation-centric framing, and Grok adds domain-plausible yet unverified mechanisms (e.g., commissions, special projects), which can improve perceived readability but remain weakly traceable to the provided data, yielding lower groundedness with comparatively better utility.

In contrast, the proposed tool is scored higher because it remains anchored to the required variable structure (Operational 2 × 2 aggregation vs Strategic ≥ 3-variable synthesis) while minimizing unsupported extrapolation, thereby improving factual groundedness, contextual alignment, and actionable clarity across both examples.

Consistent with this rationale, Figure 5 shows that the proposed tool maintains the strongest overall profile across both query families and all three axes. In Operational prompts (i.e., 2 × 2 combinations), it is systematically rated higher in factual groundedness and context relevance because it preserves the requested aggregation level and produces dataset-faithful numeric summaries, whereas the API-based baselines exhibit weaker traceability and occasional context drift, with Gemini 1.5 showing the largest degradation on fact-sensitive operational reporting. In Strategic prompts (i.e., three-variable-or-more combinations), the proposed tool sustains high context relevance and utility/clarity while remaining evidence-oriented, indicating that it can move from descriptive reporting to multi-factor interpretation without losing alignment to the underlying data.

GPT-5.2 typically ranks second by delivering coherent narratives that are often useful but not consistently evidenced, Grok tends to be more competitive in readability and perceived relevance but trails on factual groundedness when it introduces unverified assumptions or reframes the measurement scale, and Gemini 1.5 more frequently underperforms when the prompt requires multi-factor conditioning rather than a single global statistic.

Beyond these findings, a significant outcome of the applied evaluation protocol highlights the necessity of adopting a human-in-the-loop paradigm when assessing and deploying LLMs, particularly in analytical and decision-support set-tings. A key observation concerns the lack of consistency exhibited by API-based approaches. Repeated executions of the same query often produced divergent answers, and additional variability was observed when different evaluators interacted with the same models. Such instability undermines reproducibility and weakens the reliability of conclusions derived from these systems. In contrast, the proposed tool demonstrated deterministic behavior, consistently returning identical outputs for identical inputs, thereby satisfying a fundamental requirement for scientific evaluation and operational deployment.

A second critical issue relates to hallucination and self-assessment bias. When API-based models were prompted to evaluate their own performance against predefined qualitative metrics, they produced inconsistent and, in some cases, para-doxical self-evaluations. This behavior indicates the presence of intentional or structural bias, whereby the model’s generative objective interferes with its ability to act as an impartial evaluator. The absence of an external verification mechanism allows such bias to persist unchecked, potentially leading to misleading assessments and overconfidence in model outputs.

Traceability further differentiates the proposed approach from purely API-driven models. Contemporary API-based LLMs do not maintain persistent, queryable knowledge bases and therefore cannot provide verifiable evidence or provenance for the facts they generate. As a result, users are unable to trace outputs back to concrete data points or validate intermediate reasoning steps. The proposed tool addresses this limitation by grounding responses in an explicit knowledge base, enabling fact storage, retrieval, and inspection. This design supports transparency and facilitates post hoc auditing of results. Taken together, these findings demonstrate that human-in-the-loop involvement is not merely beneficial but necessary. Human oversight provides a stabilising layer that mitigates inconsistency, detects hallucinations, and counters self-evaluation bias.

Moreover, it enables informed judgement over grounded evidence, particularly in scenarios where accountability, reproducibility, and explainability are critical. Without such oversight, reliance on autonomous API-based models risks introducing hidden bias and epistemic uncertainty into ana-lytical workflows, whereas a human-in-the-loop framework offers a principled path toward trustworthy and verifiable intelligent systems.

VII. DISCUSSION.

In this paper, we have developed and empirically examined a transparent-by-design HR decision-support system that operationalizes explainability, traceability and human over-sight as architectural properties. The empirical results provide concrete support for the architectural claims presented in this work while also clarifying their scope. Across the selected collection of operational and strategic HR scenarios, the proposed system achieves moderate-to-high fact-level performance (mean F1 = 0.677) along with mean traceability completeness of 0.680, hallucination resistance of 0.733, query-level accuracy of 0.733, and low mean response latency (t = 0.067 seconds). These aggregate values reflect heterogeneous task difficulty rather than stochastic behavior.

In particular, queries for which sufficient structured evidence exists are handled with perfect or near-perfect correctness and traceability, whereas queries lacking adequate support in the KG yield conservative failures with zero-valued scores. Although such failures reduce average performance, they represent a deliberate design choice aligned with high-stakes HRM requirements, where abstention is preferable to specu-lative inference. It should also be noted that identical queries yield identical outputs, thus underscoring the determinism and reproducibility afforded by the evidence-centric design. Comparative qualitative evaluation against API-based LLMs reinforces these findings, especially by showing that while general-purpose models may produce fluent responses, they exhibit inconsistency, limited factual grounding, and an inability to provide verifiable provenance.

In contrast, the proposed system trades unrestricted generative flexibility for reliability, auditability and governance alignment, specific properties that are critical in HRM contexts where decisions must be justified, contestable and reproducible. All these results indicate that transparency and explainability need not be treated as abstract ethical aspirations, but can be operationalized as measurable system properties when architectural constraints, provenance mechanisms and agent-level responsibility are treated as first-class design elements.

The proposed system improves transparency by making each stage of information processing explicit, inspectable and attributable at the architectural level. Transparency is not treated as an interface feature, but as a property of the underlying data and control flow. All information–whether directly extracted from HR documents or derived through statistical or operational analysis–is stored in a shared RDF KG as explicit facts, each enriched with provenance metadata specifying its source document, producing agent, timestamp, and confidence score. This design ensures that no assertion enters the system without a traceable origin. Moreover, the multi-agent orchestration layer decomposes system behavior into specialized, clearly scoped components whose interactions are mediated exclusively through the KG.

Query routing decisions are logged and exposed, allowing users to see which agents were activated and why. As a result, the system’s internal state and decision pathways remain observable rather than hidden behind monolithic model calls, enabling both real-time inspection and post hoc auditing–capabilities that are essential in HR contexts subject to legal, ethical, and organizational scrutiny.

Explainability is achieved through a combination of structural decomposition and evidence-centric response con-struction. At the computational level, analytical results– such as correlations, descriptive statistics, or group-level aggregates–are materialized as first-class graph facts rather than transient computations. These facts can be queried, visualized, and reused independently of the original query that triggered their creation. At the interaction level, every system response is accompanied by an ordered set of supporting facts selected via a transparent relevance-ranking mechanism. Users are thus presented not only with an answer, but with the minimal evidence set required to justify it, expressed in human-readable subject–predicate–object form and linked back to original documents.

Importantly, the LLM component is constrained to operate solely as a linguistic interface and synthesis mechanism over this evidence set; it cannot invent new facts or infer beyond what is stored in the graph. This strict separation between reasoning over evidence and natural-language articulation ensures that explanations correspond to actual system state rather than to latent model heuristics.

The combination of transparency and explainability forms the foundation of trust, which, in this system, is constructed through design rather than assumed implicitly. In particular, trust emerges because users can verify claims, trace them back to their sources and understand how different com-ponents have contributed to the final output. The explicit attribution of facts to agents enables accountability at the component level, while duplicate prevention through normalization and hash-based checks improves internal consistency. From a human-centric perspective, the proposed system preserves user authority by exposing uncertainty through confidence scores and surfacing alternative evidence while avoiding forced or prescriptive recommendations.

Instead of positioning AI as an autonomous decision-maker, the architecture frames it as an epistemic assistant that organizes, analyzes and explains organizational data in a controlled and auditable way. Therefore, the system aligns technical reliability with organizational trust requirements, thus demonstrating how trust in AI-supported HR decision-making can be constructed through design choices that prioritize traceability, auditability and human oversight.

A. IMPLICATIONS FOR INFORMATION RETRIEVAL AND GENERATIVE ARTIFICIAL INTELLIGENCE RESEARCH

From the perspective of IR and Generative AI research, the proposed system can be understood as a concrete instantiation of a broader shift away from purely gener-ative retrieval pipelines toward grounded, auditable, and governable retrieval architectures. Contemporary IR systems increasingly rely on LLMs to interpret queries, reformulate search intent, and synthesize results; however, this fluency often comes at the cost of epistemic reliability, as generative models blur the boundary between retrieved evidence and inferred content. By contrast, our architecture enforces a strict separation between retrieval and generation since all retriev-able units are symbolic facts stored in a provenance-aware KG and the LLM is constrained to operate only over the evidence explicitly returned by graph queries.

This design reframes the role of the LLM in IR from a primary reasoning engine to a controlled interface layer, thus aligning generative capabilities with the principles of relevance, traceability and verifiability of classical IR. By adopting this design, the system addresses a central open problem in Generative IR, namely how to exploit the expressive power of LLMs without sacrificing the epistemic guarantees historically linked to retrieval-based systems. It should be noted that these findings are further supported by recent work in Generative IR, which highlights the epistemic risks of tightly coupling retrieval and generation in LLM-based systems and argues for architectures that enforce explicit separation, grounding and verifiability of retrieved evidence.

In this sense, our results can be seen as an applied instantiation of these emerging principles in a high-stakes HRM decision-support setting.

Within this context, neurosymbolic grounding emerges as a viable and principled path forward for Generative AI in IR. Rather than attempting to encode relational structure implicitly within model parameters, the system externalizes knowledge into an explicit symbolic substrate–the RDF KG–over which reasoning and aggregation are performed. Neural components contribute language understanding, query interpretation, and explanation generation, but they are systematically grounded in symbolic representations that encode entities, relations, and constraints. This grounding mitigates well-known failure modes of neural retrieval, such as entity conflation, relational hallucination, and sensitivity to prompt phrasing, by ensuring that generative outputs correspond to stable symbolic states.

This perspective is reinforced by recent surveys on neurosymbolic reason-ing in KG, which identify explicit symbolic substrates and modular neural–symbolic separation as key enablers of interpretability, constraint satisfaction and human-level accountability. From a research standpoint, this suggests that future Generative IR systems should be evaluated not only on relevance or fluency metrics, but also on their grounding fidelity, especially the degree to which generated responses can be reconstructed from, and justified by, an explicit symbolic retrieval layer.

The system further advances IR research by demon-strating how multi-agent architectures can function as an explainability mechanism, rather than merely as a scala-bility or engineering solution. In traditional IR pipelines, query interpretation, ranking, aggregation and presentation are often collapsed into opaque, tightly coupled modules. Here, these functions are decomposed across specialized agents–routing, statistical analysis, operational aggregation and synthesis–whose interactions are mediated through a shared KG. This decomposition makes the retrieval process itself inspectable since users and auditors can observe which agents were activated, which facts were retrieved or derived and how these intermediate artefacts contributed to the final answer.

These design choices are consistent with findings from explainable goal-driven agent research, which shows that transparency and trust arise from modular agent decomposition, explicit internal representations and inspectable reasoning workflows rather than post-hoc expla-nation of opaque models. Therefore, for IR research, the results of our study point toward a shift from explaining models to explaining retrieval workflows, where transparency arises from modular orchestration and explicit intermediate representations rather than from post-hoc interpretability techniques applied to monolithic models.

B. ORGANIZATIONAL IMPLICATIONS

From an organizational perspective, the proposed system addresses several concerns relevant to fairness, accountability and governance that increasingly shape the acceptability of AI-mediated decision-making explicitly described in previous studies. In particular, accountability is oper-ationalized through explicit assignment of responsibility among system components. The multi-agent architecture ensures that every action, such as data extraction, statistical computation, aggregation or synthesis, is attributable to a specific agent with a clearly defined role. This design choice aligns with organizational accountability structures where decisions must be explicable not only in the outcome but also in the process.

When an HR insight is challenged, the organization can identify whether the issue originates from the quality of the source data, the extraction logic, the analytical thresholds or the interpretation of the query, rather than attributing the failure to an opaque ‘‘AI system’’ as a whole. This granularity supports internal audit processes, facilitates compliance with emerging AI regulations and enables substantive human supervision by HR professionals, legal teams and worker representatives. In this way, the system embeds accountability into the technical workflow in a way that mirrors established organizational governance practices.

With respect to AI governance, the system offers a practical framework for translating abstract principles, such as trans-parency, explainability and human-in-the-loop control, into enforceable technical mechanisms. Governance is supported through persistent audit trails, agent-level logging, and the ability to reconstruct decision pathways retrospectively. These features are particularly relevant in light of regulatory frameworks that emphasize documentation, risk management and contestability of automated decisions. Rather than relying on policy statements or usage guidelines alone, the architecture enforces governance constraints through design. For example, LLM outputs are bounded by retrieved evidence, confidence and uncertainty are made visible and users retain interpretive authority over final decisions.

From an organizational perspective, this enables AI systems to be integrated into existing governance structures, such as ethics committees, works councils or compliance units, without requiring those bodies to trust inscrutable models. More broadly, the work demonstrates how generative AI can be aligned with societal expectations not by reducing its capabil-ities, but by embedding it within transparent, accountable and governable IS that respect both organizational responsibility and individual rights.

C. LIMITATIONS AND FUTURE RESEARCH

Despite the significant benefits brought forward by the proposed decision-support system, several limitations are worth reporting. While the design is essential for traceability and auditability, it introduces non-trivial storage and query overhead as the volume of organizational data grows. In large-scale or longitudinal HR settings, continuous ingestion and recomputation of analytical facts can lead to rapid graph expansion and increased retrieval latency, even in parallel processing configurations. Future research should, therefore, investigate mechanisms for scalable provenance manage-ment, including temporal summarisation, fact versioning and selective materialization strategies that preserve auditability while controlling graph growth. Another limitation relates to the dependence of the system on the quality and normative validity of the HR data upstream.

Although the architecture prevents hallucination and exposes the origins of every claim, it does not eliminate bias embedded in historical records, evaluation practices and/or organizational structures. Future work should, therefore, integrate fairness-aware analytics directly into the fact generation and aggregation processes, enabling the system not only to reveal but also to diagnose and potentially mitigate biased patterns before they are operationalized in decision-support outputs. The strictly evidence-constrained generative design of the system is also another limitation. By constraining the LLM to operate exclusively over retrieved, graph-stored facts, the archi-tecture effectively eliminates hallucination and ungrounded inference.

However, this constraint also limits the system’s ability to support exploratory, counterfactual, or forward-looking analyses that extend beyond existing organizational data. Future research could explore controlled extensions of this paradigm, such as explicitly marked hypothetical facts, simulation agents and/or scenario-generation modules, that preserve provenance and accountability while enabling limited forms of counterfactual reasoning.

Finally, the external validity of the empirical evaluation should be interpreted with caution. This specifically relates to the evaluation protocol, which has been applied to a single public HR dataset comprising 311 employee records and 36 variables. This dataset, together with the adopted scenario library, provides a controlled and reproducible proof-of-concept setting for assessing the feasibility of the proposed architecture. However, its size, structured format, public nature and limited scenario coverage restrict the direct gener-alization of the results to larger, noisier or real organizational HR datasets.

Due to its modular design, the system would be expected to scale effectively in such environments by relying on its provenance-aware storage, entity normalization, dupli-cate prevention, modular agent-based processing and parallel extraction mechanisms to preserve robustness, scalability and auditability. Nevertheless, these capabilities require further empirical validation under more heterogeneous conditions, including larger volumes of data, missing or inconsistent records, evolving schemas, conflicting evidence across sources and semi-structured or unstructured HR documents.

Future research can therefore extend the assessment along two complementary dimensions: a) larger-scale empirical evaluation involving a broader pool of evaluators, such as HR practitioners, auditors or policy stakeholders, which would enable systematic analysis of inter-rater agreement, usability perceptions and organizational acceptance under real-world conditions; and b) application of the proposed architecture to additional HR datasets with different structural properties, which would further test the robustness and generalizability of the system.

VIII. CONCLUSION.

This paper demonstrates that transparency, explainability and trust in AI-supported HR decision-making are primarily architectural properties rather than outcomes that can be reli-ably achieved through post-hoc interpretability techniques. The results show that embedding provenance, accountability and human oversight directly into system design, especially through a provenance-aware KG, a modular multi-agent orchestration layer and a strictly evidence-grounded LLM interface, enables generative AI systems to operate within the evidentiary, reproducibility and governance constraints required in high-stakes organizational contexts.

Through scenario-based evaluation on realistic HR analytics tasks, the proposed architecture exhibits deterministic behavior, measurable traceability, resistance to hallucination and low response latency, while deliberately failing conservatively when sufficient evidence is not available. These findings indicate that symbolic structure, agent-level task decom-position and conversational interaction can jointly support reliable and explainable decision support without relying on unrestricted generative inference. Beyond the HR domain, the work contributes to IS and Generative AI research by illustrating that trustworthy AI does not necessarily arise from increasingly complex or opaque models, but from evidence-centric information infrastructures that render reasoning pathways inspectable, contestable and auditable.

The main contribution of this paper lies in articulating and operationalizing such an infrastructure, providing a con-crete blueprint for governable generative systems. Looking forward, this perspective motivates a research agenda that shifts emphasis away from isolated model performance and toward the systematic design and evaluation of AI systems that align technical capabilities with organizational accountability, fairness and societal expectations.

APPENDIX.

QUERIES USED FOR PERFORMANCE TESTS

This appendix provides the complete list of queries used in the experimental evaluation. Queries are grouped by category according to their analytical purpose: operational, strategic, and evidence retrieval.

A. OPERATIONAL QUERIES

1) PERFORMANCE SCORE BY DEPARTMENT.

1) What is the distribution of performance scores by.

department?

2) How do performance scores vary across departments?

3) Which department has the highest average performance.

score?

4) Show me performance metrics by department.

2) SPECIAL PROJECTS COUNT BY DEPARTMENT.

1) What is the average special projects count by depart-.

ment?

2) How do special projects vary across departments?

3) Which department has the highest average special.

projects count?

4) Show me special projects distribution by department.

3) ENGAGEMENT BY MANAGER.

1) What is the team-level engagement by manager?

2) How does engagement vary by manager?

3) Which manager has the highest team engagement?

B. STRATEGIC QUERIES

1) MULTI-CRITERIA EMPLOYEE SEARCH.

1) Identify employees with high performance, low engage-.

ment, and many special projects.

2) Find employees with high performance, low engage-.

ment, and low satisfaction.

3) Find employees with high performance, low engage-.

ment, low satisfaction, and many special projects.

4) Find employees with low engagement, low satisfaction.

many special projects, and many absences.

2) DEPARTMENT–SALARY–PERFORMANCE ANALYSIS.

1) Which.

departments have high salaries but low performance?

2) Analyse the relationship between salary, performance.

and department.

3) Identify.

departments with low salary and high performance.

C. EVIDENCE RETRIEVAL QUERIES

1) EMPLOYEE-SPECIFIC FACT RETRIEVAL.

1) Retrieve facts related to employee Becker, Scott.

2) What information do we have about employee Becker.

Scott?

2) HIGHEST SALARY EMPLOYEE.

1) Give me facts about the employee with the highest.

salary.

2) Retrieve facts about the employee who has the highest.

salary.

3) Show me information about the highest paid employee.

3) LOWEST PERFORMANCE EMPLOYEE.

1) Give me facts about the employee with the lowest.

performance.

2) Retrieve facts about the employee who has the lowest.

performance score.

3) Show me information about the employee with the worst.

performance.

ACKNOWLEDGMENT.

The authors sincerely thank the Associate Editor and the two anonymous reviewers for their careful evaluation, construc-tive comments, and valuable suggestions, which significantly improved the quality and clarity of the manuscript.