Abstract
Modern military decision-making demands real-time integration of structured knowledge, causal reasoning, and dynamic operational context. We introduce ARES-KG (Actionable & Reasoned Edge Support over Knowledge Graphs), a hybrid decision-support framework whose central contribution is the integration of explicit causal graph semantics—relations such as BLOCKS_ROUTE, LIMITS_MOBILITY_OF, and DELAYS, elevated to first-class queryable edges—into an LLM–KG pipeline. This design lets commanders trace multi-order operational effects (e.g., bridge destruction → mobility degradation → resupply delay → mission slippage) and answer counterfactual queries through deterministic graph traversal rather than free-form LLM speculation. Three supporting elements operationalize the central claim: a closed-loop NL→Cypher interaction layer that makes the causal layer accessible at staff tempo with full auditability; a lightweight ontology-driven CSV→Neo4j architecture suitable for hybrid edge-cloud deployment; and an eight-dimensional human–AI evaluation rubric in which one dimension, Causal Foresight, directly tests the central claim. In a synthetic brigade-level case study, ARES-KG generated transparent, explainable reasoning chains and exposed hidden multi-hop dependencies across sustainment, maneuver, fires, ISR, and C2. In a small-scale study with 10 active-duty officers spanning ranks from second Lieutenant to Colonel, an ARES-KG–enabled LLM achieved a Decision Support Score in the upper band of the sample—at the field-grade rank-group mean and above every junior officer—while producing answers in seconds rather than minutes. ARES-KG thus represents a concrete step toward next-generation human–AI collaborative command systems that augment, rather than replace, expert judgment under operational time pressure.
1. Introduction
In recent years, large language models (LLMs) have emerged as transformative tools in the field of artificial intelligence, capable of generating coherent and contextually relevant natural language, performing complex reasoning, and interacting seamlessly with users [1,2]. Trained on vast corpora of text, LLMs such as GPT-4 and Claude Sonnet exhibit remarkable proficiency in tasks including information retrieval, summarization, question answering, and inference [3]. Their general-purpose architecture enables flexible use across domains without extensive fine-tuning, making them particularly well-suited for decision support applications where unstructured data, real-time interaction, and adaptive reasoning are essential [4].
Parallel to this development, knowledge graphs (KGs) have established themselves as a robust framework for modeling structured knowledge [5]. KGs encode entities and the relationships between them in a semantically rich, machine-readable format, enabling graph traversal, query answering, and logical inference. They are especially valuable in high-stakes domains where interpretability, traceability, and modularity of knowledge are critical [6]. In contrast to the statistical nature of LLMs, KGs offer symbolic reasoning and support formal representation of domain ontologies [7].
The combination of LLMs and KGs offers a compelling synergy: while KGs provide grounding and structure, LLMs supply reasoning flexibility and a user-friendly natural language interface [8]. This integration allows decision support systems to respond to complex, context-dependent queries by leveraging both the symbolic structure of a KG and the inferential power of LLMs [9]. Users can express high-level goals or problems in natural language, which LLMs translate into structured queries executed over the KG, with the outputs reinterpreted and contextualized by the model [10].
In the domain of military decision-making, this hybrid approach addresses longstanding challenges of information overload, interpretability, and responsiveness. Tactical and operational environments are dynamic, uncertain, and highly interdependent. Decision-makers must evaluate multiple potential courses of action under time pressure and incomplete information. KGs can capture the formal structure of military doctrine, unit capabilities, and operational dependencies, while LLMs enable users to interact with this structure in a fluid and adaptive manner. Furthermore, when KGs are enriched with causal relationships—such as the dependencies between supply lines, mobility, and operational effectiveness—LLMs can be used to reason over these graphs and anticipate second- or third-order effects of specific actions or disruptions.
This paper investigates the integration of KGs and LLMs for real-time operational decision support through the development of a new hybrid framework, ARES-KG (Actionable & Reasoned Edge Support over Knowledge Graphs). ARES-KG represents an applied case study in the fusion of symbolic and generative AI, purpose-built for dynamic, high-stakes decision environments such as military operations.
In contrast to existing approaches that treat KGs and LLMs as complementary yet separate technologies, ARES-KG establishes a unified, ontology-driven pipeline that operationalizes this integration from data representation to causal reasoning and natural-language interaction. It leverages the structured expressivity of KGs to encode doctrinal knowledge, unit dependencies, and operational constraints, while employing LLMs as mediators that translate unstructured user intents into machine-executable queries and contextualize their results in narrative form. The framework extends beyond conventional question-answering or summarization models by embedding explicit causal relationships among operational entities, enabling the system to trace downstream effects and explore qualitative what-if scenarios through edge removal—a core requirement for anticipatory operational planning.
What differentiates ARES-KG from prior work is its action-oriented and explainable reasoning loop, where every natural-language query corresponds to a verifiable graph operation and returns both structured results and interpretable causal justifications. Unlike static decision-support tools or black-box neural models, ARES-KG grounds every inference in a transparent chain of relationships visible to the end user. This design bridges the gap between symbolic traceability and generative adaptability, allowing decision-makers to explore what-if scenarios with both speed and analytical depth.
The central contribution of this paper is the integration of explicit causal graph semantics for multi-order operational foresight into a hybrid LLM–KG decision-support pipeline. Whereas prior KG–LLM hybrids treat the graph primarily as a factual lookup layer, ARES-KG elevates causal dependencies—such as BLOCKS_ROUTE, LIMITS_MOBILITY_OF, ENABLES_SURVEILLANCE, and DELAYS—to first-class, queryable relations. This design enables the system to (i) trace second- and third-order operational effects (e.g., bridge destruction → mobility degradation → resupply delay → mission slippage), and (ii) answer counterfactual “what-if” queries through deterministic graph traversal rather than free-form LLM inference. Causal foresight thus becomes a computable rather than a narrative property of the decision-support system.
Three supporting elements make this central contribution operational and verifiable. First, a closed-loop NL→Cypher interaction layer allows commanders to express causal queries in natural language while preserving an auditable trail from prompt to Cypher to result; this is the mechanism that makes the causal layer accessible at staff tempo without requiring graph-query expertise. Second, a lightweight CSV→Neo4j ontology-driven architecture makes the causal KG rebuildable deterministically from files; the on-device footprint (graph store, schema-locked prompt, Cypher execution, ingestion script, result rendering) is suitable for hybrid edge-cloud deployment under realistic bandwidth and compute constraints, with LLM inference delegated to a remote endpoint in the present implementation. This is the engineering enabler for the central claim. Third, an eight-dimensional human–AI evaluation rubric, applied to a comparison of an ARES-KG–enabled LLM against 10 active-duty officers, provides empirical evidence for the central claim—in particular, dimension D5 (Causal Foresight) is designed to test exactly the property that causal semantics integration is meant to deliver. We note explicitly that ARES-KG is designed as a defense-domain decision-support framework rather than a general-purpose KG + LLM system; the ontology, causal vocabulary, and evaluation rubric are all tailored to military operational reasoning. Cross-domain extensions are addressed in the Conclusions (Section 6) as planned future work.
Beyond system design, we empirically benchmark ARES-KG against human decision-makers. Using a synthetic brigade-level vignette, we compare an ARES-KG–enabled LLM to 10 active-duty officers on the same set of 20 operational questions, scoring each full response on an eight-dimensional rubric covering correctness, mobility, sustainment, C2, causal foresight, risk handling, explanation clarity, and doctrinal safety. The results show that the LLM–KG agent achieves a DSS in the upper band of a ten-officer sample stratified by rank and branch (Table 1)—at the field-grade rank-group mean and above every junior officer in the sample, while answering at machine tempo. This human–AI comparison grounds our claims about ARES-KG not only in structural expressivity and query performance, but also in how closely its outputs approximate real staff work.
Table 1.
Comparison between human officers in various ranks and ARES-KG.
Collectively, these contributions situate ARES-KG as a concrete step toward human–AI collaborative command systems that combine machine precision with human interpretability. By coupling the structured discipline of KGs with the adaptive reasoning of LLMs, the framework provides a transparent, reproducible, and operationally grounded approach to decision support. It thus moves the discussion of AI in military decision-making from theoretical speculation toward an implementable, experimentally validated model for real-time causal foresight and operational reasoning.
The structure of the paper is as follows. Section 2 presents related work. Section 3 describes the proposed approach followed for this line of research. Section 4 presents the experiments and their results, and Section 5 discusses them critically. Finally, Section 6 summarizes the key findings of this study and provides plans for future research.
2. Related Work
Recent work systematically explores how LLMs and KGs can be combined. Pan et al. [11], Kau et al. [12], Khorashadizadeh et al. [13], Li et al. [14] and Lavrinovics et al. [15] provide taxonomies of KG-enhanced LLMs, LLM-augmented KGs, and hybrid/cooperative models, showing that deeper integration can improve factuality, interpretability and KG construction, while also identifying challenges such as limited domain-specific KGs, high computational and training costs, fragile prompting, and very low effective knowledge integration. However, these works are primarily surveys or position papers: they lack systematic empirical comparisons, do not fully analyze scalability and efficiency in real-world settings, and only partially reflect the latest rapid developments.
A second line of work proposes concrete LLM and KG architectures for reasoning and Question Answering (QA). Yasunaga et al. [16] (QA-GNN), Tan et al. [17] (PoG) and Ao et al. [18] (LightPROF) show that injecting structured KG signals into the reasoning process improves multi-hop and KGQA performance, often outperforming larger vanilla LLMs; yet all depend heavily on KG quality, introduce non-trivial architectural complexity or adapters, and are evaluated on a narrow set of benchmarks, limiting generalizability. Dai et al. [19] analyze how different encodings of KG triples affect LLM behavior, finding linearized triples often superior to natural language, but also exposing model-specific preferences and reduced robustness of larger models, complicating universal prompt or schema designs. Yao et al. [20] use instruction-tuned LLMs for KG completion with strong results on some tasks, but weaker entity prediction and focus on a single tuning paradigm, which constrains broader applicability.
Finally, domain-specific systems illustrate the promise and constraints of LLM–KG integration in specialized settings. Bai et al. [21] built a large materials-science KG and coupled model (Qwen2-KG), achieving large QA gains, and Gao et al. [22] (DR.KNOWS) integrated medical KGs with LLMs for diagnostic reasoning, while Matsumoto et al. [23] (ESCARGOT) use dynamic graphs-of-thought plus biomedical KGs to reduce hallucinations and increase transparency. These systems demonstrate substantial benefits for accuracy, traceability and knowledge-intensive reasoning, but are limited to specific domains, rely on potentially biased or incomplete KGs, require complex pipelines (e.g., path ranking, code execution, domain-tailored adapters), and lack evidence of scalability or robustness across heterogeneous, real-world decision-making environments. Furthermore, Zhang et al. [24] propose Command-Agent, a multi-agent LLM framework integrated with a digital twin battlefield for real-time military decision-making, demonstrating improved tactical performance but without explicit ontology-driven or causal knowledge graph reasoning.
Although existing studies have explored diverse strategies for integrating LLMs and KGs, several important limitations remain evident. Pan et al. [11] and Li et al. [14] provide comprehensive taxonomies of hybrid architectures, yet their analyses remain largely conceptual, focusing on classification and typology rather than deployable systems. Their frameworks identify the theoretical complementarity of symbolic and statistical reasoning but do not address how these can be operationalized in real-time, data-intensive settings. Yao et al. [20] and Li et al. [14] propose models that enhance LLMs through factual grounding in KGs; however, these methods are still data-centric and lack explicit causal semantics, making their reasoning process non-transparent and contextually brittle in dynamic environments. Dai et al. [19] and Gao et al. [22] advance experimental hybrids for multi-hop reasoning and domain-specific information retrieval but remain constrained by high computational cost, limited generalizability, and an absence of reproducible evaluation in operational decision-making scenarios. Similarly, Ao et al. [18] focus on causal-enhanced reasoning but primarily within static or simulated contexts, leaving open questions of explainability, provenance tracking, and human interpretability in live applications. Collectively, these studies reveal a research gap in creating hybrid LLM–KG systems that are not only accurate but also transparent, causally grounded, and deployable in real-time operational environments.
The proposed ARES-KG framework addresses these limitations by transforming the LLM–KG integration paradigm into a fully operational, ontology-driven decision-support system. Building upon the insights of Pan et al. [11] and Liu et al. [25], ARES-KG extends hybrid architectures from conceptual taxonomies into a functioning pipeline capable of supporting causal consequence analysis and explainable reasoning in dynamic safety-critical domains. Unlike Yao et al. [20] and Li et al. [14], who focus primarily on factual enrichment, ARES-KG embeds explicit causal dependencies between entities—such as resources, assets, infrastructure elements, and operational tasks—allowing the system to reason about cascading and counterfactual effects in environments such as military operations, border security and search and rescue missions. In contrast to the high-complexity models of Dai et al. [19] and Gao et al. [22], ARES-KG emphasizes lightweight edge deployability through direct CSV-to-Neo4j construction and LLM-generated Cypher queries, ensuring efficiency and transparency in resource-constrained settings. Moreover, building on Ao et al. [18], ARES-KG introduces a closed-loop natural-language-to-graph reasoning cycle, coupling human interpretability with auditable, provenance-rich outputs. Through these innovations, the framework advances the state of the art by providing a reproducible, explainable, and operationally grounded approach that bridges the gap between theoretical hybrid architectures and actionable decision-support systems in real-world environments.
3. The ARES-KG Framework
The proposed ARES-KG (Actionable & Reasoned Edge Support over Knowledge Graphs) (Figure 1) framework establishes a unified, ontology-driven pipeline that operationalizes the integration of symbolic knowledge representation and generative reasoning for military decision support. The framework transforms heterogeneous operational data into an interpretable knowledge structure, enabling human operators to obtain actionable and causally grounded insights through natural-language interaction. Its design philosophy rests on four principles—actionability, reasoned inference, edge deployability, and provenance—each addressing persistent challenges of current AI-assisted command systems.
Figure 1.
The ARES-KG pipeline.
Before describing the pipeline in detail, we make explicit the sense in which ARES-KG performs “causal” reasoning. The framework does not implement formal causal inference in the sense of structural causal models, do-calculus, or probabilistic counterfactual computation [26]; nor does it attempt to learn causal structure from observational data. Rather, ARES-KG treats causality at a qualitative, doctrine-encoded level: domain experts (and, in the prompting stage, an LLM constrained to the scenario tables) declare directed influence relations among operational entities—e.g., BLOCKS_ROUTE, LIMITS_MOBILITY_OF, ENABLES_SURVEILLANCE, DELAYS—and these relations are materialized as typed edges in the graph. Multi-order effect tracing is then performed by graph traversal along these named edges, and “counterfactual” queries (e.g., “if Bridge Alpha is destroyed”) are implemented as virtual edge removal during traversal rather than as formal interventions in a probabilistic causal model. This scope is deliberate: operational decision support at the tactical edge requires fast, inspectable, doctrine-aligned what-if reasoning rather than statistically identified causal effects, and the assumption that the encoded edges correctly reflect operational influence is held by the domain expert authoring the ontology, not by the system itself. Throughout the remainder of this paper, the term causal is used in this operational/doctrinal sense (directed, named, traversable influence) rather than the statistical sense (identifiable, probabilistic, intervention-based). Section 4.3 returns to this scope when discussing the limits of counterfactual queries in the current implementation.
The process begins with a clear definition of the operational domain and the formulation of competency questions (CQs) that express the actual informational needs of commanders. These questions guide the entire modeling chain, ensuring that every representational and reasoning element serves a concrete operational purpose rather than abstract data description. To capture doctrinal knowledge, unit dependencies, and environmental constraints, an LLM is prompted to generate an initial ontology describing entities, properties, and causal relations among them. The ontology is refined through expert validation and directly aligned with the CQs, creating a transparent mapping between battlefield problems and representational constructs. Unlike static ontologies designed for archival purposes, this one is purpose-built to drive reasoning and simulation of cascading operational effects.
Ontology concepts are then translated into structured tabular datasets that represent the key dimensions of the scenario—units, missions, assets, logistics, communications, mobility, disruptions, and locations. These datasets are cleaned, validated, and imported into a Neo4j database, where the LLM generates Cypher scripts to instantiate the nodes, edges, and properties of the operational graph. At this stage, ARES-KG departs from traditional descriptive KGs by embedding causal and temporal semantics as first-class relations. Edges such as CAUSES, AFFECTS, and LEADS_TO model dynamic dependencies—for example, how the destruction of a bridge blocks a route, reduces mobility, and ultimately delays a mission. This causal encoding enables forward propagation of doctrine-encoded effects and qualitative counterfactual exploration via virtual edge removal, thus converting the knowledge graph into an executable, inspectable reasoning environment (in the operational, not statistical, sense.
A central innovation of ARES-KG lies in its natural-language-to-Cypher translation layer, which allows operators to interact with the graph without technical expertise. The LLM interprets user queries, generates schema-aware Cypher statements, executes them against the KG, and translates the structured results into concise operational narratives. Questions such as “Which units can reinforce Hill 402 within 2 hours?” or “What are the downstream effects if Bridge Alpha is destroyed?” are automatically resolved into graph traversals whose results are summarized as short, doctrinally relevant briefs. This closed reasoning loop ensures that each answer remains both verifiable—because the Cypher query is auditable—and interpretable—because the natural-language output explains the causal pathways underlying the result. In doing so, ARES-KG provides a human-centered interface that fuses the precision of symbolic computation with the linguistic flexibility of generative AI.
The framework’s validation takes place through scenario-based evaluations involving subject-matter experts and military officers. These experiments assess correctness with respect to doctrine, response time compared with manual reasoning, success rate of query execution, and perceived transparency of the explanations. Special attention is given to causal foresight—testing whether the system can identify and articulate second- and third-order effects of operational disruptions such as supply failures or communication outages. As shown in Section 4, ARES-KG improves both decision accuracy and time-to-answer while maintaining an auditable, reproducible chain of reasoning.
To ensure traceability and reproducibility, every natural-language query, Cypher translation, and corresponding graph result is automatically logged, allowing analysts to replay and verify previous sessions. The framework’s lightweight architecture—CSV data ingestion, Neo4j storage, and an LLM-mediated interface—gives it a small on-device footprint suitable for hybrid edge-cloud deployment (Section 4.5). Security and governance considerations, including role-based access control and audit logging of high-impact queries, are discussed as deployment requirements in Section 4.6. Continuous improvement is achieved by feeding evaluation results back into ontology refinement, dataset augmentation, and prompt tuning, ensuring that the system evolves with operational requirements.
In summary, ARES-KG delivers a rigorously engineered and operationally validated hybrid pipeline that bridges the longstanding gap between symbolic transparency and generative adaptability. By embedding causal reasoning directly within an auditable graph structure and providing natural-language access to its logic, the framework transforms abstract knowledge integration into a deployable, human-interpretable decision-support capability. It thus constitutes a practical step toward next-generation human–AI collaborative command systems, combining doctrinal fidelity, causal foresight, and explainable intelligence under real-world operational constraints.
All experimental data, prompt designs, reasoning outputs, and evaluation results are documented in a dedicated GitHub 3.21.1 repository (https://github.com/dimitrisdoumanas19/DSS-ARESKG, accessed on 14 May 2026) to ensure transparency and reproducibility.
4. Results
The Results section is organized following an integrated phase-by-phase structure rather than a conventional Methods–Results split. Section 4.1 presents the methodology-with-scenario-instantiation: each phase of the ARES-KG pipeline—ontology construction, CSV-to-KG ingestion, NL→Cypher translation, and execution against the operational scenario—is described with its concrete artifacts (the actual ontology terms, the Cypher script, and the 20 operational questions). Section 4.2 presents the comparative evaluation of those outputs against 10 active-duty officers under the eight-dimensional Decision Support Score rubric, including baseline ablations against an LLM-with-raw-CSVs configuration and a manually-authored-Cypher configuration (Section 4.2.5). Section 4.3 (Error Analysis and Limitations) identifies the failure modes and the operational, reliability, and ethical limitations of the present implementation; Section 4.4 (Reproducibility) consolidates the commitments that make the framework deterministically reproducible; Section 4.5 (Computational Performance) reports latency, footprint, and deployment characteristics; and Section 4.6 (Robustness and Security Considerations) addresses hallucination, adversarial, and security posture. Five representative operational walkthroughs are provided in Appendix B. The conceptual architecture of ARES-KG is presented separately in Section 3. This integrated organization is deliberate: in design-as-contribution work, separating the conceptual methodology from its concrete instantiation produces either an operationally ungrounded methods section or duplicated scenario context across sections.
4.1. Scenario Modeling Results-Query Translation and Operational Output
We begin by defining a concrete operational problem set in a mixed-terrain battlespace with time-critical constraints. The scenario centers on the defense of the Eastern approaches, with the key terrain such as Hill 402, a Western Ridge, mobility corridors like Route X and River Z crossing (Bridge Alpha/beta), and weather conditions that realistically degrade line-of-sight and maneuver (fog at high ground, rain in low ground). Friendly forces comprise company-to-squad—level formations with attached support (artillery, engineers, medics, logistics), while the adversary pressure and tempo create genuine trade-offs among reinforcement, resupply, and communications resilience. This framing ensures that every modeled entity has an operational purpose: it either enables or constrains a commander’s next move.
The team’s military background guided which knowledge must be represented to support decision-making under pressure. In practice, staff officers reason about five interacting layers: (i) forces (who, where, readiness, threat, parent/child task organization), (ii) missions (objective, priority, assigned unit, sustainment needs), (iii) terrain and environment (terrain type, line of sight, weather), (iv) means (assets such as bridges, artillery, UAVs, depots, comms nodes), and (v) flows (mobility and supply). Attributes were selected because they shift courses of action: readiness and threat levels drive whether a unit can reinforce; terrain, LOS, and weather drive whether fires and ISR are effective; asset status and location drive availability and coverage; mobility capacity and supply type/priority drive whether missions slip or hold. Crucially, we elevate causal dependencies—for example, “bridge destroyed → route blocked → mobility degraded → resupply delayed → mission risk increases”—from implicit narrative to explicit, queryable structure.
We operationalized this scope into an ontology that keeps the battlefield objects simple and the effects explicit. Core classes are Unit, Asset, Location, Mission, CommNode, Mobility, with n-ary “event” classes for things that carry attributes of their own: SupplyRequirement (Unit↔Asset with SupplyType and Priority), Disruption (Asset↔Mission with DisruptionType and Severity), and LocationMobilityEffect (Location↔Mobility with EffectType). Object properties capture the relationships commanders actually ask about: Unit–LOCATED_AT→Location, Unit–HAS_MISSION→Mission, Asset–SUPPORTS→Unit, Asset–DISRUPTS→Mission, Location–AFFECTS→Mobility, Unit–REQUIRES_SUPPLY_FROM→Asset, and CommNode–SUPPORTS_COMM_FOR→Unit. On top of these, we define a generic causallyAffects relation with operational sub-relations (e.g., BLOCKS_ROUTE, LIMITS_MOBILITY_OF, ENABLES_SURVEILLANCE, SUPPLIES_AMMUNITION_TO, PROVIDES_COMMUNICATIONS_FOR), so “why” is first-class in the graph rather than buried in prose.
To keep the build reproducible at the edge, we encoded the scenario as normalized CSVs whose headers map one-to-one to ontology data properties and whose foreign-key-style fields drive the edges. For example, units.csv provides UnitID, UnitName, UnitType, ReadinessLevel, Location, ParentUnit, MissionName, NeedsReinforcement, ThreatLevel. Here, the scalar fields become data properties of Unit, while Location, ParentUnit, and MissionName/AssignedUnit are used to create LOCATED_AT, hasParentUnit, and HAS_MISSION links. Likewise, assets.csv defines what an asset is, where it is, its status, and which unit it supports; locations.csv captures terrain, LOS, and weather; missions.csv binds objectives and priorities to the assigned unit and whether sustainment is required; communications.csv records node types and attachments for C2 resilience. Three operational tables ground the effects layer: supply_requirements.csv (which unit needs which supply from which asset, and how urgently), disruptions.csv (what asset disrupts which mission, and how severely), and location_mobility.csv (how specific terrain and conditions affect specific mobility assets). Finally, causal_relations.csv expresses the named, typed effects (e.g., Bridge Alpha BLOCKS_ROUTE Route X; UAV-Z ENABLES_SURVEILLANCE Mission Sentinel), so the graph can answer “what if” directly.
This design deliberately preserves provenance (CSV row ↔ node/edge) and semantic stability (ontology terms remain fixed even if the data refreshes hourly). It also matches how operators think: as soon as an asset status flips, a road is interdicted, or weather closes in, the corresponding edges and attributes update and downstream queries (reinforcement eligibility, alternate resupply, ISR coverage, comms redundancy) change in real time. In short, Phase 1 turns a realistic tactical vignette into a compact, causally expressive schema whose fields and relations are chosen because they materially affect a commander’s options.
To avoid any risk of factual leakage or “shortcutting” to preconceived answers, we explicitly note that the operational vignette used in ARES-KG is entirely hypothetical and bears no relation to real events, units, or locations. All entities, attributes, and causal links are synthetic and exist solely to exercise decision-support reasoning. Accordingly, when we involve an LLM in any step (e.g., ontology drafting or NL→Cypher translation), we instruct it to disregard prior knowledge and rely only on the information provided in the attached scenario tables (CSVs) and the stated modeling constraints. This data-grounding requirement prevents the model from drawing on external memory, forces explicit reasoning over the structured inputs, and enables reproducible, auditable outputs aligned with the scenario’s declared scope.
To draft the ontology, we used OpenAI’s ChatGPT 5.0 and attached the finalized CSVs that encode the scenario ground truth—units, assets, locations, missions, communications, mobility, supply requirements, location–mobility effects, disruptions, and named causal relations. We then issued a single consolidated prompt that first states the aim and scope of ARES-KG (an operational ontology for real-time decision support with explicit causal effects) and, second, lists every table with its headers so the model can derive classes, datatype properties, and object properties directly from the data. We emphasized that the scenario is entirely hypothetical and unrelated to real events and instructed the model not to use prior knowledge or external memory; the ontology must be built only from the attached files and the modeling constraints we provide. The prompt fixes the base IRI and prefixes; declares the core classes (Unit, Asset, Location, Mission, CommNode, Mobility) plus three n-ary “event” classes for facts that carry their own attributes (SupplyRequirement, Disruption, LocationMobilityEffect); and specifies how foreign-key style columns induce relations such as locatedAt (Unit→Location), hasParentUnit (Unit→Unit), hasMission (Unit→Mission), supports (Asset→Unit), supportsCommFor (CommNode→Unit), operatesAt (Mobility→Location), requiresSupplyFrom (Unit→Asset), and affectsMobility (Location→Mobility). The prompt also asks the model to create a causal superproperty, causallyAffects, with subproperties named exactly as they appear in the causal_relations file (e.g., BLOCKS_ROUTE, ENABLES_SURVEILLANCE, PROVIDES_COMMUNICATIONS_FOR), and to assign sensible ranges to scalars (integers for readiness, booleans for yes/no flags). Finally, we request a compact JSON mapping at the end of the output that mirrors CSV headers to ontology terms to facilitate ETL and NL→Cypher generation.
Once the model returns the Turtle file, we validate it in Protégé to confirm that every class and property referenced by the CSV mapping exists, that domains and ranges are coherent, and that the file loads cleanly with no unresolved prefixes (Figure 2). Minor adjustments (for example, normalizing label casing or switching a yes/no text field to xsd:boolean) are fed back to the LLM as small patch prompts until the ontology passes validation. This loop is fast because the source of truth is the CSV set; any change in a header or relation can be reflected deterministically in the ontology and rerun.
Figure 2.
The LLM-generated ontology (as depicted in Protégé).
With the ontology stabilized, we author competency questions by starting from operational decisions we expect staff to make over these entities and relations. The rule we apply is that each question must be answerable over the graph without external assumptions and must bind explicitly to ontology terms. For example, questions about reinforcement potential reference Unit (type, readiness, threat) in combination with Location (terrain, line of sight, weather) and Mobility (capacity and status), so that “Which platoons can reinforce Hill 402 within 2 hours?” becomes a precise query that filters platoons by readiness and proximity while considering any route closures encoded as causal effects like BLOCKS_ROUTE.
Questions about sustainment tie SupplyRequirement (supply type and priority) to Asset status and then to Mission via hasMission, so “If fuel reserves drop below threshold, which missions will be delayed?” becomes a traversal from fuel-providing assets through dependent units to their missions. Communications resilience questions traverse CommNode→Unit→Mission with mission priority as a weighting, which allows “Which communications nodes are most critical for mission continuity?” to be evaluated using graph centrality or cut-set logic. Effects-chain questions are framed deliberately around the causal vocabulary—“What are the cascading effects if Bridge Alpha is destroyed?” traces from a bridge asset through BLOCKS_ROUTE into mobility degradation and onward to resupply and mission slippage—so the “why” is explicit in the path.
In practice, we drafted the full set of competency questions by scanning each class and asking which of its attributes or relations could change a course of action. For Units this meant readiness, threat, location, and task-organization; for Missions, priority and objective coupled to the assigned unit and supply requirements; for Assets, type, status, and placement; for Locations, terrain, line of sight, and weather; for Mobility, capacity and operating location; and for the causal layer, the named effects that encode what happens when conditions change. We then rewrote the natural-language questions so that each one corresponds to a clear pattern of nodes and edges in the graph, ensuring they are both natural for an operator to ask and precise enough to translate into Cypher. This CQ set, paired with the ontology produced from the LLM prompt, gives us a reproducible, data-grounded basis for NL→Cypher evaluation in later phases.
We translated the ontology into a normalized tabular schema so the graph can be rebuilt deterministically from files. Each core class becomes a CSV with stable identifiers and scalar attributes captured as typed columns (e.g., UnitID, UnitType, ReadinessLevel, ThreatLevel in units; TerrainType, LineOfSight, WeatherCondition in locations), while foreign-key style fields drive edges during ingest. Concretely, Unit.Location materializes LOCATED_AT (Unit→Location), Mission.AssignedUnit and Unit.MissionName materialize HAS_MISSION (Unit→Mission), Asset.SupportsUnit materializes SUPPORTS (Asset→Unit), CommNode.SupportsUnit materializes SUPPORTS_COMM_FOR (CommNode→Unit), Mobility.Location materializes OPERATES_AT (Mobility→Location), supply_requirements (UnitID,AssetID,SupplyType,Priority) reifies REQUIRES_SUPPLY_FROM (Unit→Asset) with attributes on the event, location_mobility (LocationID,MobilityID,EffectType) reifies AFFECTS (Location→Mobility), and disruptions (AssetID,MissionID,DisruptionType,Severity) reifies DISRUPTS (Asset→Mission). Named causal impacts from causal_relations (e.g., BLOCKS_ROUTE, ENABLES_SURVEILLANCE, SUPPLIES_AMMUNITION_TO) are preserved as typed relationship labels so downstream queries can reason over effects rather than free text. Throughout, we enforce case-sensitive IDs (U01, A01, L01), coerce booleans/integers at the CSV level, and keep only concepts present in the scenario, avoiding speculative nodes. This CSV-first representation provides provenance, supports edge deployment (simple LOAD CSV … MERGE), and prepares the dataset for NL→Cypher in Phase 4.
We materialized the ontology into a working graph by exporting the scenario tables as CSV and placing them in Neo4j’s/import directory, then using a single LLM-authored Cypher script to load everything deterministically. we used Claude 3.7 Sonnet to auto-generate the Cypher ingestion script, as our prior evaluations showed it outperforms other LLMs for schema-aware, idempotent Neo4j code generation [9] (Figure 3). The script begins with schema hardening—CREATE CONSTRAINT … REQUIRE <id> IS UNIQUE for each core label (Unit, Asset, Location, Mission, CommNode, Mobility) and a few helper indexes on frequently filtered attributes (e.g., name, type)—so subsequent merges are idempotent. For each file the LLM emits a LOAD CSV WITH HEADERS FROM ‘file:///…’ AS row block that trims text fields, coerces types (toInteger, boolean normalization for Yes/No), and uses MERGE to create or match nodes on their canonical IDs (UnitID, AssetID, etc.) while setting scalar properties from the remaining columns. Foreign-key style columns become edges in the same pass: Unit.Location instantiates (:Unit)-[:LOCATED_AT]->(:Location), Mission.AssignedUnit and Unit.MissionName instantiate (:Unit)-[:HAS_MISSION]->(:Mission), Asset.SupportsUnit yields (:Asset)-[:SUPPORTS]->(:Unit), CommNode.SupportsUnit yields (:CommNode)-[:SUPPORTS_COMM_FOR]->(:Unit), and Mobility.Location yields (:Mobility)-[:OPERATES_AT]->(:Location). N-ary operational tables are reified as small event nodes so we preserve their attributes: rows in supply_requirements.csv become (:SupplyRequirement {supplyType,…}) linked by [:FOR_UNIT] and [:FROM_ASSET] (or, equivalently, a single [:REQUIRES_SUPPLY_FROM] edge with relationship properties); location_mobility.csv becomes (:LocationMobilityEffect {effectType}) tied to a Location and a Mobility; and disruptions.csv becomes (:Disruption {disruptionType, severity}) tied to the causing Asset and affected Mission. Causal impacts are loaded from causal_relations_enhanced.csv by matching the named endpoints and creating typed relationships that mirror the ontology’s sub-properties (e.g., [:BLOCKS_ROUTE], [:ENABLES_SURVEILLANCE], [:SUPPLIES_AMMUNITION_TO]), allowing downstream queries to reason over effects rather than free text; where APOC is available we optionally call apoc.create.relationship (source, row.RelationshipLabel, {}, target) to keep the loader generic across labels.
Figure 3.
The LLM-generated Cypher script for KG Generation from Claude 3.7.
To protect data quality, the script enforces case-sensitive identifiers (e.g., U01 is not Uo1), normalizes whitespace with trim, and runs in small transactional batches so partial failures are isolated and reruns are fast. After ingestion we perform sanity checks directly in Neo4j Browser (Figure 4): counts per label match row counts; every mission has exactly one assigned unit; units with NeedsReinforcement = ‘Yes’ appear in at least one supply path; bridge nodes that BLOCKS_ROUTE actually gate reachable locations; and critical comm nodes sit on expected SUPPORTS_COMM_FOR cut-sets. Finally, we visualize subgraphs (units around Hill 402, the Route X logistics chain, surveillance coverage from UAV and radar assets) to verify that the command/support chains and causal edges reflect the scenario narrative. This procedure yields a reproducible, idempotent build: drop the CSVs into/import, run the LLM-generated Cypher once, and the complete ARES-KG appears with the exact nodes, properties, and typed relationships required for NL→Cypher in the next phase.
Figure 4.
The LLM-generated knowledge graph.
Next, we put the graph to work exactly as an operations cell would. We let operators ask in plain English and we translated those questions to Cypher against the fixed ARES-KG schema, so no one needed to touch the query language.
Concretely, we posed 20 questions that mirror the decisions a commander must take next: we asked which support units are closest to the eastern flank, what units are at risk if Bridge X is destroyed, if fuel reserves drop below 30% which missions will be delayed, which platoons can reinforce Hill 402 within 2 hours, what the downstream effects are of a failed resupply to FOB Bravo, which artillery assets have line of sight to Sector Delta, what units are currently operating at reduced readiness, if UAV Alpha loses communication which surveillance zones become blind, which units require reinforcement based on proximity to high-threat zones, and what operational nodes are affected if the supply route via Road Y is disrupted. We then broadened the probe set to include what missions are linked to units stationed in mountainous terrain, what the command relationships are between Unit A, B, and C, which mobility-dependent units are impacted if weather worsens, which assets are underutilized in the western sector, what units are currently without direct fire support, how many units can cross River Z if Bridge Beta is operational, what flanking options open up if an enemy retreat is detected, which logistics chains depend on Fuel Depot Gamma, what communications nodes are most critical for mission continuity, and what the cascading effects are if Artillery Position Delta is compromised. Each question matters tactically because it anchors a concrete next action: mass or hold, reroute or repair, re-task fires or ISR, harden C2 or accept risk. In practice we found that the answers arrived in two forms that a commander can act on immediately: a graph/table result (e.g., candidate platoons with times and routes) and a two-sentence operational narrative that explains the “so-what” in plain language.
To convert natural language into executable queries, we locked the LLM to the known schema and asked it to emit Cypher only. We specified the valid labels (Unit, Asset, Location, Mission, CommNode, Mobility, SupplyRequirement, Disruption, LocationMobilityEffect), the relationships (LOCATED_AT, HAS_MISSION, SUPPORTS, SUPPORTS_COMM_FOR, OPERATES_AT, REQUIRES_SUPPLY_FROM) and the typed causal edges (e.g., BLOCKS_ROUTE, ENABLES_SURVEILLANCE, SUPPLIES_ AMMUNITION_TO), along with case-sensitive identifiers (e.g., U01) and simple normalization (trim strings, coerce integers/booleans). We used Claude 3.7 Sonnet for the translation because, in our prior work, it consistently produced correct, idempotent Cypher for schema-aware tasks and needed fewer edits than alternatives [9]. In the present implementation, ARES-KG was operated through the consumer interface of the language-model provider (claude.ai for Claude 3.7 Sonnet), which does not expose decoding-parameter controls. Reproducibility properties of the framework, therefore, derive from the architectural commitments described above—idempotent graph construction, schema-locked NL→Cypher translation, and deterministic Cypher execution against the static graph—rather than from decoding-parameter control. For counterfactuals such as “if Bridge X is destroyed,” we instructed the model either to compute virtually (treat the blocking edge as absent in the traversal) or to run the what-if inside a transaction that is rolled back after measuring impacts, so the database state remains clean. We verified each generated query by checking label counts and path predicates in Neo4j Browser, then returned both the result set and a short “ops summary” that ties the finding to a decision (e.g., “reinforce Hill 402 with Bravo Platoon via Route X within 90 min; reroute fuel through Bridge Beta to avoid a 6-h slip”).
After the LLM translated the operational questions into Cypher (Figure 5), the queries were executed against ARES-KG (Figure 6) and the resulting tables and short “so-what” summaries were inspected to assess operational implications. This procedure converts natural-language intent into reproducible graph analytics without manual query authoring, enabling systematic evaluation of dependencies, chokepoints, and feasible actions across sustainment, maneuver, fires, ISR, and C2.
Figure 5.
Translation of the CQs from natural-language-to-Cypher queries with Claude 3.7.
To illustrate how the schema-locked NL→Cypher loop converts natural-language operational questions into auditable graph analytics, five operational walkthroughs are provided in Appendix B. The walkthroughs span the principal categories of military reasoning the framework is claimed to support—sustainment-chain tracing, fires deconfliction, mobility–weather coupling, counterfactual analysis under enemy retrograde, and C2 criticality with multi-hop traversal—and each presents the question posed, the executed Cypher result, and a short operational narrative tying the finding to a concrete decision.
Beyond the human-authored questions, the LLM also inferred useful tactical analysis queries from the schema and generated them autonomously. First, it assembled a “complete tactical picture” for high-threat areas by joining Unit—LOCATED_AT→Location with optional overlays of supporting assets, communications nodes, and missions. This composite view functions as a one-screen staff brief: it reveals which exposed units lack redundant comms, which have insufficient fires or ISR coverage, and where immediate risk-reduction actions (second relay, on-call fires, observer tasking) are warranted. Second, it proposed a reinforcement capability query that filters units by readiness thresholds and excludes those already needing reinforcement, returning a ready roster of formations that can be attached at short notice and the specific units they can backstop. This is operationally valuable because it transforms a generic “who can help?” question into a pre-vetted, time-feasible reinforcement list aligned with current posture. Third, it produced a supply-chain vulnerability query over REQUIRES_SUPPLY_FROM that cross-references unit supply priority (High/Critical) with the status and location of provider assets and hubs. The result surfaces single-point dependencies and co-located demand on the same depots, enabling pre-emptive rerouting, forward caching, or duplication of fuel and ammunition lines before a disruption propagates into mission delays. Taken together, these self-generated queries indicate that, under tight schema guardrails, the LLM is able to internalize the operational semantics of ARES-KG and propose analytics that are both computable and actionable, reducing staff effort in assembling common operational pictures while preserving decision authority with the commander.
4.2. Comparison to Human Reasoning
To assess how close ARES-KG–enabled LLM reasoning comes to real officers’ staff work, we ran a direct human–AI comparison on the same 20 operational questions used in the NL→Cypher evaluation. Ten active-duty officers (from second Lieutenants to Colonels, across Infantry, Armour, Signals, Engineers, Technical Corps, and Logistics) independently answered the full set of questions based on the written scenario. In parallel, the LLM + KG pipeline generated Cypher queries over ARES-KG for each question, executed them, and produced textual answers. Each complete 20-question response (one per officer and one for the LLM + KG agent) was then evaluated using a structured rubric of military decision quality.
4.2.1. Rubric and Decision Support Score (DSS)
We designed an eight-dimensional rubric to capture not only correctness, but also the quality of military reasoning:
- Task correctness & completeness (D1)—Does the proposed course of action align with doctrinally sound, scenario-consistent solutions? Are key units, assets and missions correctly identified, without critical omissions?
- Mobility & spatial awareness (D2)—How well does the answer reason about terrain, routes, bridges, choke points, and time–distance constraints that affect movement and reinforcement?
- Sustainment & logistics (D3)—Does the answer explicitly consider fuel, ammunition, resupply nodes, maintenance, and the risk of overextending units or single-point failures in logistic chains?
- C2 (command and control) robustness & coordination (D4)—To what extent are command relationships, critical communications nodes, and synchronization between units made explicit and used in the reasoning?
- Causal foresight (D5)—Does the answer anticipate second- and third-order effects (e.g., how the loss of a bridge propagates through mobility, resupply, and eventually mission feasibility)?
- Risk awareness & mitigation (D6)—Are key risks identified (e.g., chokepoints, exposed assets, fragile links) and are concrete mitigation measures or fallback options proposed?
- Explanation clarity & traceability (D7)—Is the reasoning structured, easy to follow, and explicitly grounded in scenario facts and the information present in ARES-KG?
- Safety & doctrinal compliance (D8)—Does the answer avoid clearly unsafe, impossible, or doctrinally unacceptable actions, and show awareness of rules of engagement and basic force-protection principles?
Each dimension was scored on an ordinal 0–3 scale, where
0 = absent or clearly wrong,
1 = weak or partial,
2 = good,
3 = excellent.
Figure 6.
Results on queries 4, 5, 12, 16 and 18.
For each agent a (officer or LLM + KG) and its full 20-question response, we obtained:
and normalized this to a decision Support Score (DSS) on a 0–100 scale:
This DSS reflects overall decision-support quality aggregated across the eight dimensions; higher values correspond to more complete, well-reasoned, and doctrinally safe answers.
4.2.2. Scoring Humans and the LLM + KG Agent
Each officer’s full response (all 20 questions taken together) was read and scored on D1–D8. For instance, the first participant (a Captain in the Technical Corps) produced a clear, mobility-focused answer that correctly identified Bridge Alpha, the forward fuel depot, key support units, and critical communications assets. However, their response was relatively compact, with limited explicit treatment of C2 structure and only moderately developed causal chains. Under the rubric, this yielded:
- D1–D8 = (2, 2, 2, 1, 2, 2, 2, 3)
- Sraw = 16
- DSS = (16/24) × 100 ≈ 66.7.
The same procedure was applied to the remaining nine officers. Scores naturally increased with rank and experience: junior officers tended to give correct but narrower answers with less explicit logistics, causal foresight and formal C2 reasoning, while field-grade officers and Colonels wrote much richer analyses.
For the ARES-KG–enabled LLM, we used the actual NL→Cypher queries and KG structure to judge correctness and completeness, and the generated textual answers to judge the qualitative dimensions. The query set correctly captured all 20 natural-language questions over ARES-KG (e.g., identifying support units closest to the eastern flank, units at risk if Bridge Alpha is destroyed, missions dependent on Fuel Depot Gamma, or cascading effects of losing Artillery-2), and the associated answers were detailed, entity-rich, and explicitly grounded in the KG. On the rubric, the LLM + KG agent attained excellent scores on correctness, mobility, sustainment, causal foresight, explanation clarity, and doctrinal safety, and slightly lower (but still good) scores on fully explicit C2 structuring and risk-mitigation narrative.
- D1, D2, D3, D5, D6, D7, D8 = 3 (excellent)
- D4 = 2 (good)
- DSSLLM+KG = (23/24) × 100 ≈ 95.8
4.2.3. Quantitative Results
Table 1 summarizes the rubric outcomes for all ten officers and the LLM + KG agent, treating each complete 20-question response as one composite decision-support product.
The ten-officer sample (Table 1) was designed for rank-and-corps diversity rather than statistical power: participants span the full active-duty rank range from second Lieutenant to Colonel and represent 6 military branches (Technical Corps, Infantry, Artillery, Signals, Engineers, Logistics), providing calibrated human reference points across the spectrum of decision-support consumers the framework targets. The standard decision-making cell trained in officer schools comprises five to seven officers of the same rank; the present sample exceeds this baseline and adds rank stratification.
Averaged by rank group, the pattern is:
- second Lieutenants: mean Sraw = 18.5, DSS ≈ 77.1
- Captains: mean Sraw = 19.5, DSS ≈ 81.3
- Majors: mean Sraw = 23.0, DSS ≈ 95.8
- Lieutenant Colonels: mean Sraw = 22.5, DSS ≈ 93.75
- Colonels: mean Sraw = 23.0, DSS ≈ 95.8
- LLM + KG: Sraw = 23.0, DSS ≈ 95.8
Under this rubric, the ARES-KG–enabled LLM:
- Clearly outperforms junior officers (second Lieutenants and the weakest Captain, DSS ≈ 62–77).
- Matches or slightly exceeds some experienced officers (e.g., Officer 2 and the Logistics Colonel, both at DSS ≈ 91.7).
- Approaches, but does not fully reach, the best human decision-makers (Majors, Lieutenant Colonels, and the Artillery Colonel at ≈96–100).
In other words, the LLM + KG system delivers decision-support quality that is much closer to field-grade officers than to junior officers, even though it has no real-world operational experience.
4.2.4. Dimensional Comparison and Tempo
The rubric also makes it possible to reason about how the LLM + KG agent differs from humans along specific dimensions:
- On Task correctness and completeness (D1) and Explanation clarity and traceability (D7), the LLM + KG generally matches the strongest human officers, as it systematically enumerates all relevant units, assets and missions returned by the KG and explains their relationships in a structured way.
- On Mobility & spatial awareness (D2) and Sustainment & logistics (D3), the agent consistently performs at an expert level, because ARES-KG encodes key routes, chokepoints, depots and support relations, which the LLM can query and verbalize without overlooking details that humans might omit under time pressure.
- On Causal foresight (D5), the LLM + KG agent tends to articulate longer and more explicit chains of second- and third-order effects (e.g., loss of a bridge → blocked resupply → ammo depletion → degraded fire support → breach in the defense), again benefiting from the causal layer of ARES-KG.
- On Safety & doctrinal compliance (D8), the agent remains conservative: it does not propose clearly unsafe or impossible actions, and its recommendations are broadly consistent with doctrinal principles encoded in the scenario.
- The main area where the LLM + KG agent is slightly weaker than top human officers in our scoring is C2 robustness and coordination (D4). Senior officers often bring additional implicit doctrine and operational “pattern recognition” to bear, offering richer C2 constructs and more nuanced risk-mitigation schemes (e.g., specific command relationships, habitual coordination patterns, or experience-driven contingency plans) than the LLM currently articulates.
Finally, tempo is where the hybrid approach is most clearly advantageous. Human officers required non-trivial deliberation time to read the scenario and construct a coherent narrative answer across the 20 questions, whereas the ARES-KG–enabled LLM can translate each natural-language query into Cypher, execute it over the KG, and generate a detailed explanation within seconds. This means that, for comparable decision-support quality (DSS ≈ 95.8, close to senior officers), the LLM + KG pipeline can provide recommendations at a much higher operational tempo. In time-sensitive contexts—such as rapidly evolving border or battlefield situations—this combination of near-expert quality and machine-level speed is precisely what makes ARES-KG a promising decision-support asset rather than a mere demonstration of NL→Cypher capabilities.
4.2.5. Ablation Against LLM + Raw CSVs and Manually Authored Cypher Baselines
To quantify the contribution of the ARES-KG components beyond the underlying language model and the operational data, we ran a controlled ablation comparing the full pipeline (scenario → ontology → Neo4j graph → NL→Cypher → answer) against two baselines suggested by reviewers. B2—LLM + raw CSVs preserves the data and the language model and removes only the components ARES-KG introduces: a commercial LLM is given the scenario narrative and the ten scenario CSVs directly, with no ontology, no Neo4j instance, no schema-locking prompt, and no Cypher generation. B3—Manually authored Cypher preserves the KG and the graph queries and removes only the NL→Cypher automation: a graph-fluent author writes Cypher directly against the ARES-KG schema and returns the raw result tables. We did not include a strict “standalone LLM with no data” baseline because removing the CSVs from the LLM eliminates the operational ground truth itself—units, assets, locations, missions and named causal relations—and therefore tests data availability rather than reasoning capability.
To make the LLM-dependence of the B2 baseline visible, we ran the LLM + raw CSVs configuration on two independent commercial models (GPT-5.5, accessed on 16 May 2026, and Gemini 3 Flash, accessed on 17 May 2026) with identical prompts and CSV attachments and in fresh sessions with no prior context. ARES-KG itself was run with Claude 3.7 Sonnet as in the rest of this paper.
In addition to the eight-dimensional DSS rubric used throughout Section 4.2, we report four supplementary metrics. Entity Hallucination Rate (EHR) is the fraction of named entities (units, assets, locations, missions, comm nodes) appearing in a response that do not exist in the scenario ground truth. Provenance/Auditability Score (PAS) is an ordinal 0–3 measure per question (0: no traceability; 1: references facts without source citation; 2: cites a source artifact; 3: backed by an executable, replayable query), summed across the 20 questions for a maximum of 60. Mean Latency per Query (MLQ) is the wall-clock time per response averaged across the 20 questions. Cross-LLM Consistency Rate (CCR) is the fraction of questions for which two runs of the same configuration on two different commercial LLMs produce semantically equivalent answers; for ARES-KG it is computed against the architectural property that identical Cypher executed against an unchanged graph returns identical results. Table 2 summarizes the comparison.
Table 2.
Baseline comparison across the eight-dimensional DSS rubric and four supplementary metrics. B2 was run on two commercial LLMs (GPT-5.5 and Gemini 3 Flash) to expose cross-LLM consistency; ARES-KG uses Claude 3.7 Sonnet as in the rest of the paper. MLQ is the mean latency per query; CCR is Cross-LLM Consistency Rate. Arrows indicate the direction of improvement.
The DSS gap between ARES-KG and the B2 cross-LLM average is approximately 27 points, equivalent in the human comparison reported in Section 4.2.3 to the difference between senior field-grade officers and 2nd-Lieutenants. On the rubric, B2 dropped from 3 to 2 on six of the eight dimensions: D1 (task correctness and completeness—the baseline occasionally falls back on speculation when a question is not directly answerable from a single CSV), D2 (mobility and spatial awareness—combining route, terrain and capacity for time–distance reasoning is weaker without the graph), D3 (sustainment and logistics—cascading effects truncate after one or two hops), D5 (causal foresight—the baseline cannot traverse named causal edges and instead infers causation by reasoning over tables, producing shorter chains), D6 (risk awareness and mitigation—risks are named but mitigations remain generic), and D7 (explanation clarity and traceability—provenance is asserted by citing source files but is not replayable). The two systems were equivalent on D4 (tacit C2 doctrine, where neither baseline encodes habitual command patterns) and on D8 (doctrinal conservatism, where the language-model layer alone is sufficient).
The Cross-LLM Consistency Rate is the clearest single piece of evidence for the schema-locking and graph-determinism contributions of ARES-KG. Of the 20 operational questions, only four (Q6, Q8, Q10, Q20) produced semantically equivalent answers across the two commercial LLMs in the B2 configuration. The remaining 16 differed in non-trivial respects: different units identified as affected, different cascading-effect chains, different mitigation recommendations, and in two cases (Q4, Q17) a structurally different response posture, with one LLM answering the question and the other refusing on the grounds that required parameters were absent from the data. In addition to a small set of hallucinated entities common to both LLMs (e.g., “Comm Tower Bravo”, which is absent from the validated communications-node list of the scenario), the Gemini 3 Flash run introduced further hallucinated entities (“Supply Depot Echo”, “Ammo Depot Charlie”) and several specific quantitative claims with no basis in the CSV data (“48-h immobilization”, “6 eastern units”, “3 critical sectors”), elevating its hallucination rate to approximately 6% versus 2% for GPT-5.5. ARES-KG, by contrast, returned 0% hallucinations across both metrics by construction, since the schema-locked NL→Cypher layer cannot emit entity names or quantitative properties absent from the graph. ARES-KG, by contrast, executes the same LLM-generated Cypher against the same graph and would return the same result set regardless of the LLM used to translate the natural-language query; the only source of cross-LLM variation is the final narrative wrap, which does not change the underlying decision content. The 0.20 vs. 1.0 CCR gap, therefore, corresponds directly to the deployment-relevant question of whether a commander can trust that two different command posts running the same scenario will arrive at the same recommended actions.
The B3 (Manual Cypher) baseline isolates the tempo contribution of the NL→Cypher layer. A graph-fluent author with no prior familiarity with the specific ARES-KG schema authored Cypher for five representative questions (Q1, Q4, Q5, Q8, Q19, covering simple lookup, multi-condition filter, multi-hop traversal, counterfactual, and centrality respectively) in 34 min total—an average of 408 s per query, including the time required to reconcile foreign-key relationships across the ten CSV files comprising the schema. The same five queries are emitted by the NL→Cypher layer in approximately 7.5 s end-to-end (Cypher generation, execution, and narrative wrapping combined), a 54-fold tempo improvement. In the operational setting that ARES-KG targets—command posts under time pressure where staff officers are not graph-query specialists—this difference is not a refinement but a feasibility threshold: 408 s per query is incompatible with brigade-level decision tempo, while 7.5 s is well within it.
Substantively, the three baselines decompose the ARES-KG contribution into three load-bearing components, each empirically separable. The causal graph layer drives the DSS and hallucination gains over B2 (∆DSS ≈ 27 points; ∆EHR ≈ 4 percentage points). The schema-locking and deterministic Cypher properties drive the cross-LLM stability gain (∆CCR = 0.80). The NL→Cypher automation drives the tempo gain over B3 (∆MLQ ≈ 400 s per query). Removing any one of these components materially degrades a different operational property of the decision-support system, supporting the central design claim of Section 1.
4.3. Error Analysis and Limitations
Despite the strong aggregate performance reported above, a systematic examination of failure modes is essential to characterize the boundaries of ARES-KG’s reliability and to inform future development. We identify four distinct error categories arising from the NL→Cypher translation layer, the KG coverage, the rubric evaluation methodology, and the causal reasoning mechanism.
NL→Cypher Translation Failures. Although the LLM successfully generated executable Cypher for all 20 operational questions in the evaluation set, the translation layer remains a structural source of brittleness. Ambiguous or underspecified natural-language queries can produce syntactically valid but semantically incorrect Cypher: for example, a question such as “Which units are exposed?” does not unambiguously resolve to a specific property combination in the schema (e.g., high threat level, low readiness, no fire support coverage, or all of the above simultaneously), and the LLM must make an implicit scoping decision that may not align with the commander’s intent. Similarly, multi-hop traversals involving more than three relationship types of risk path over-generation, where the LLM includes spurious intermediate nodes that produce inflated result sets. In our evaluation these effects were controlled by locking the model to the known schema and using schema-aware prompts, but this constraint itself represents a limitation: any deviation from the declared labels or relationship names—such as a new asset type added mid-operation—would require prompt re-engineering before the translation layer could handle it correctly. Counterfactual queries (“if Bridge Alpha is destroyed”) are implemented as virtual edge removal traversals rather than as formal causal interventions in a structural causal model (see Section 3, Scope of Causality). The virtual-deletion semantics are approximated at the prompt level rather than enforced at the graph level, meaning that a sufficiently complex multi-hop counterfactual could silently traverse a logically removed edge if the Cypher generation omits the appropriate WHERE clause. Equally important, the validity of any such counterfactual is bounded by the quality of the doctrine-encoded influence edges themselves: ARES-KG cannot distinguish between a domain expert assertion that “destroying Bridge Alpha blocks Route X” and a statistically identified causal effect, and an incorrectly authored edge will propagate silently through all derived effect chains. Robust deployment, therefore, requires periodic ontology audit by domain experts, and the system’s outputs should be framed as doctrine-conformant projections rather than causal predictions.
KG Coverage and Ontology-Induced Errors. ARES-KG answers questions only over the knowledge that has been explicitly encoded in the scenario CSVs. Several of the 20 operational questions required the LLM to make implicit operational judgments—such as inferring doctrinal thresholds for reinforcement eligibility or assessing whether a readiness level of 60 is sufficient for a specific mission type—that are not formally captured as graph properties. In these cases the system’s responses were based on the LLM’s parametric knowledge rather than the graph, introducing a category of answer that is neither fully KG-grounded nor auditable via Cypher provenance. This is operationally significant because the core auditability guarantee of ARES-KG—that every answer corresponds to a verifiable graph traversal—does not hold for questions that exceed the ontology’s coverage. Three of the 20 questions in our set partially fell into this category, touching on doctrinal norms (e.g., acceptable readiness thresholds for combat attachment) that were absent from the CSV schema. Future iterations must either encode these thresholds as explicit KG properties or clearly signal to the operator when an answer draws on model priors rather than graph-grounded facts.
Dimensional Weakness in C2 Reasoning (D4). The one dimension where the LLM + KG agent did not achieve an excellent score was C2 robustness and coordination (D4 = 2 versus 3 for the best human officers). Analysis of the generated answers reveals that this gap is structural rather than incidental. Senior officers bring implicit doctrinal pattern recognition—habitual command relationships, branch-specific coordination procedures, and experience-based contingency constructs—that is not reducible to graph properties. For example, the LLM correctly identified which communications nodes were most critical by traversing CommNode→Unit→Mission paths, but it did not spontaneously propose a primary/alternate communications architecture with specific fallback assignments, a construct that experienced Signals and Infantry officers offered without prompting. This reflects a known limitation of LLM–KG systems in safety-critical domains: explicit causal structure compensates for many reasoning deficiencies, but command coordination is partly a matter of tacit professional knowledge that resists formal ontological encoding. The practical implication is that ARES-KG should not be relied upon as the sole source of C2 synchronization recommendations; human review by an officer with relevant branch expertise remains necessary for this dimension.
Rubric Reliability and Evaluation Scope. The human–AI comparison was conducted with a sample of 10 officers scored by the research team using a structured rubric. While the eight-dimensional framework and the 0–3 ordinal scale provide a principled basis for comparison, the evaluation is subject to two reliability concerns. First, inter-rater agreement was not formally measured: all scoring was performed by the same evaluator. This was a deliberate trade-off to ensure rubric consistency across the 10 participants in the initial evaluation, but it precludes formal measurement of inter-rater reliability (e.g., Cohen’s κ on the per-dimension D1–D8 scores) and limits the inferential interpretation of dimensional-mean differences across rank cohorts. A follow-on evaluation with at least two independent raters per response and an expanded officer pool (n ≥ 30) is committed to in Section 6 as part of the multi-scenario evaluation program. Second, the synthetic scenario was designed by the research team and represents a controlled, bounded operational environment; it is therefore possible that the LLM + KG agent benefits from an alignment between the scenario’s ontological structure and its own output format that would not hold to the same degree in a real operational setting with noisier, less structured input data. These constraints do not invalidate the findings, but they limit the generalizability of the DSS values to other scenarios, languages of instruction, or KG schemas, and establish the need for larger-scale evaluation under field conditions.
Single-Scenario Evaluation Scope. The present evaluation rests on a single, synthetic brigade-level defensive scenario designed by the research team. This is by design—the scenario was constructed to simultaneously exercise sustainment, maneuver, fires, ISR, and C2 reasoning within one dense operational picture, which is what permits the head-to-head human–AI comparison on the full eight-dimensional rubric reported above. However, we acknowledge that one scenario, however carefully designed, cannot speak to cross-scenario or cross-domain generalizability of the framework. A multi-scenario evaluation program covering border-security and search-and-rescue domains is committed to in Section 6, with a planned cross-scenario ablation in which the ontology is held fixed while only the scenario data varies, allowing direct measurement of architectural generalizability. Until these results are available, the quantitative findings of the present manuscript (DSS, EHR, PAS, MLQ, CCR) should be interpreted as scenario-specific evidence that the ARES-KG architecture works as designed on a representative brigade-level defensive task, not as a claim of domain-general decision-support quality.
Operational Deployment Constraints. Beyond the methodological and technical limitations enumerated above, several operational constraints apply to any fielded deployment of ARES-KG that have not been the subject of empirical evaluation in this manuscript. First, the framework presupposes the availability of accurate, current, and appropriately classified scenario data in the CSV schema described in Section 4.1; in real operational settings the input data may arrive from disparate intelligence and operational systems with inconsistent formats, varying refresh rates, and conflicting confidence levels, requiring data-fusion and validation infrastructure outside the present scope. Second, integration with existing command-and-control, intelligence, and logistics information systems is not addressed by the present implementation; ARES-KG was developed as a standalone proof-of-concept rather than as a component of an operational C2 stack, and integration interfaces, data-exchange standards, and security-accreditation pathways are deliberate scope exclusions of this paper. Third, the present hardware and software environment is a commodity development workstation (Section 4.5), not a tactical-edge platform; transition to rugged-edge deployment will require benchmarking on representative hardware under realistic environmental and connectivity constraints, as committed to in Section 6. Fourth, all operator interactions with ARES-KG presuppose training on the framework’s failure modes (above), its dependence on the encoded ontology (Section 3, Scope of Causality), and the boundary between graph-grounded outputs and LLM-mediated narrative wrap; without such training, operators may misinterpret the auditability properties of the system or place inappropriate confidence in narrative summaries.
Reliability and Maintenance Limitations. Two further reliability concerns apply to long-running operational use. First, the present implementation depends on a third-party language-model provider (Section 4.4 and Section 4.5); service availability, model deprecation, and version drift are operational risks that the local-LLM migration committed to in Section 6 partially mitigates but does not entirely eliminate, since any locally-hosted model is itself subject to refresh, retraining, and validation cycles. Second, the framework’s outputs are only as reliable as the encoded ontology; doctrine evolves, equipment capabilities change, and named causal relations between operational entities require periodic re-validation. Robust deployment, therefore, requires a defined ontology-audit cadence by domain experts, with associated provenance and change-control discipline; without such an audit cycle, encoded edges may drift from current operational reality and propagate silently through derived effect chains, as already noted in the NL→Cypher Translation Failures paragraph above.
Ethical Considerations in Military Deployment. The military character of the domain places ARES-KG within the legal and ethical framework governing decision support in armed conflict, and several ethical risks apply that we identify explicitly here rather than treat as out-of-scope. First, ARES-KG is and must remain a decision-support framework that augments—not replaces—human command authority. The system’s design (auditable outputs, executable provenance, narrative wrap rather than action selection) is consistent with this commitment; nevertheless, automation bias under operational time pressure is a documented risk in human–machine teaming, and any fielded deployment requires training, doctrine, and command-review procedures designed to keep human judgment in the decision loop and to surface, rather than smooth over, cases in which the system’s recommendation departs from human assessment. Second, the framework’s outputs are subject to International Humanitarian Law and the Laws of Armed Conflict, including the principles of distinction, proportionality, and precaution; ARES-KG does not itself encode legal review, and its recommendations should be treated as inputs to—not substitutes for—IHL/LOAC-compliant decision-making by appropriately trained command and legal personnel. Third, the framework’s capability profile (causal traversal, multi-hop dependency reasoning, auditable provenance) is intentionally dual-use within the defense domain—it is designed to support defensive operations, sustainment planning, and risk mitigation, but the same architectural capabilities could be configured for offensive planning; we therefore treat domain-specific deployment review and command-authority approval as preconditions for operational use, not as administrative formalities. Fourth, civilian-protection considerations apply: ARES-KG is designed and evaluated on military-entity ontologies (units, assets, missions, communications nodes), and ontological extension to civilian populations, civilian infrastructure, or humanitarian-sensitive entities would require deliberate ethical review and is not addressed in the present manuscript. Fifth, the framework inherits the biases of its underlying language model and of its encoded ontology; periodic audit for biased reasoning patterns—particularly along lines that could systematically disadvantage particular populations, branches, or coalition partners—is identified as a forthcoming evaluation deliverable in Section 6. A consolidated ethical review and human-factors evaluation, conducted with operational and legal stakeholders, is committed to in Section 6 as part of the multi-scenario program.
Behavior under Incomplete, Inconsistent, or Rapidly Changing Data. Operational data in deployed settings is rarely as clean as the synthetic scenario used in Section 4.1. We characterize ARES-KG’s behavior under three departures from clean-data conditions: missing or incomplete entries, inconsistent or conflicting values, and rapid update tempo.
ARES-KG answers questions only over the knowledge that has been explicitly encoded in the graph; if a required entity, attribute, or relation is missing, the corresponding Cypher query returns an empty result rather than a fabricated answer. The schema-locking mechanism (Section 3 and Section 4.4) ensures that missing data manifests as null outputs at the graph layer rather than as hallucination, which is operationally preferable but does not free the operator from interpreting absence correctly: an empty result may mean “no such unit exists” or “the unit exists but the relation has not been recorded.” The framework does not currently distinguish between these two cases. In some queries (three of the 20 in our evaluation set, as noted under KG Coverage and Ontology-Induced Errors above), the LLM bridges this gap by drawing on parametric knowledge, producing an answer that is plausible but not graph-grounded; this is operationally significant because the auditability guarantee does not hold for such answers. Robust deployment, therefore, requires either explicit “absence” markers in the schema (e.g., a Last-Updated property on each relation, or a Coverage flag on each entity) or an operator-facing disclosure when an answer falls outside the graph’s coverage. The latter is identified as a forthcoming enhancement in Section 6.
The present ingestion script uses idempotent LOAD CSV/MERGE operations under unique-identifier constraints; duplicate rows with the same key are conflict-resolved at ingest time, with the last-encountered value taking precedence at the property level. The framework does not currently implement explicit conflict detection or provenance tracking at the value level: if two upstream data sources disagree about an entity’s readiness, location, or supporting asset, the inconsistency is resolved silently by ingestion order rather than surfaced for operator adjudication. This is acceptable for the controlled scenario data used in Section 4.1, but is a significant limitation for fielded deployment with multiple intelligence-feed sources. Provenance tracking at the relation and property level—recording which source contributed which value and flagging conflicts above a configurable severity threshold—is identified as a deliverable of the data-fusion work referenced in Operational Deployment Constraints above and in Section 6.
The graph rebuild from CSVs is fast (the idempotent ingestion pipeline completes in seconds for the scenario reported in Section 4.1, as documented in Section 4.5), so the framework can in principle keep pace with rapid operational updates by re-ingesting refreshed CSVs at the required cadence. The current implementation does not, however, support streaming updates or incremental delta ingestion: each refresh requires a full re-ingest from CSV, which is acceptable for scenarios that change on the order of minutes but inadequate for streaming sensor feeds or sub-second event rates. Streaming and delta-ingestion support is identified as a future-work deliverable in Section 6, alongside the scalability stress test already committed to in Section 4.5. Crucially, the deterministic-graph reproducibility property (Section 4.4) holds across refreshes by construction: re-ingesting the same CSV state produces the same graph, so a Cypher query executed against two equivalent snapshots returns identical results regardless of refresh history.
Across all three conditions, the operational risk pattern is the same: ARES-KG behaves conservatively (returning empty results, resolving conflicts deterministically, requiring full re-ingest for refresh) rather than aggressively (extrapolating, guessing, or hallucinating). This conservatism is consistent with the safety-critical orientation of the framework and is a design choice rather than an oversight; the future-work commitments in Section 6 progressively reduce the operator burden these conservative defaults create.
4.4. Reproducibility
ARES-KG is engineered to make reproducibility a property of the architecture rather than a discipline applied on top of it. Three properties of the pipeline are deterministic by construction. First, the graph build is idempotent: the Cypher ingestion script materialized from the scenario CSVs uses MERGE under unique-identifier constraints on every node and edge type, so re-running the script on the same CSV inputs reproduces an identical Neo4j graph (verified by node/edge counts and label-wise structural diffs against a stored reference snapshot). Second, the NL→Cypher layer is schema-locked: the translation prompt fixes the set of admissible labels (Unit, Asset, Location, Mission, CommNode, Mobility, and the n-ary event classes), the set of admissible relationship names (LOCATED_AT, HAS_MISSION, SUPPORTS, SUPPORTS_COMM_FOR, OPERATES_AT, REQUIRES_SUPPLY_FROM, and the typed causal sub-properties), and the case-sensitive identifier scheme, so the LLM cannot emit Cypher that references entities outside the declared schema. Third, the graph execution is deterministic: identical Cypher executed against the static graph returns identical result sets; the only LLM-dependent step downstream of the graph is the final natural-language wrap of the result, which does not modify the underlying decision content.
In the present implementation, ARES-KG was operated through the consumer interface of the language-model provider (claude.ai for Claude 3.7 Sonnet), which does not expose decoding-parameter controls. Reproducibility properties of the framework, therefore, derive from the architectural commitments described above—idempotent graph construction, schema-locked NL→Cypher translation, and deterministic Cypher execution against the static graph—rather than from decoding-parameter control. The date of execution is recorded so that the active model release at experiment time can be identified by anyone re-running the pipeline. The full set of prompts used for ontology drafting, ingestion-script generation, and NL→Cypher translation is reproduced verbatim in Appendix A. Deployment via the provider’s API, which exposes explicit temperature and top-p settings, is identified as a near-term operational step in Section 6. The complete artifact set—CSVs, ontology TTL, Cypher ingestion script, prompt templates, the 20 operational questions used for evaluation, and the executed Cypher log—is available in the public GitHub repository referenced in Section 3.
For complete reproducibility disclosure, the LLM invocations reported in this manuscript are as follows. The ontology-drafting stage (Section 4.1) used OpenAI ChatGPT 5.0, accessed via chat.openai.com on 29 November 2025. The Cypher ingestion-script generation and the NL→Cypher translation layer (Section 4.1, ARES-KG configuration) used Anthropic Claude 3.7 Sonnet, accessed via claude.ai on 29 November 2025. The B2 baseline ablations reported in Section 4.2.5 used OpenAI ChatGPT 5.5, accessed via chat.openai.com on 16 May 2026, and Google Gemini 3 Flash, accessed via gemini.google.com on 17 May 2026. In every case, access was via the language-model provider’s consumer web interface, and no decoding parameters (temperature, top-p, frequency penalty, entity penalty, or seed values) were exposed to the end user at any stage.
Empirically, the ablation reported in Section 4.2.5 quantifies the gain from these architectural commitments. The Cross-LLM Consistency Rate (CCR)—the fraction of operational questions for which two independent runs of the same configuration on two different commercial LLMs (GPT-5.5 on 16 May 2026 and Gemini 3 Flash on 17 May 2026) produce semantically equivalent answers—is 0.20 for the LLM + raw CSVs configuration and approximately 1.0 for the full ARES-KG pipeline. The 0.20 figure is the practical meaning of the reviewer-grade concern about output drift across model versions and prompt variants: in the LLM-only configuration, 80 per cent of the resulting decisions changed depending on which LLM the operator happened to deploy. ARES-KG’s schema-locking and deterministic-graph layers are the components that close this gap.
We note three residual sources of variation that users should be aware of when extending the framework to new scenarios. (a) The ontology-drafting stage is performed once per domain and remains the only place where qualitative LLM judgment enters the build; we mitigate this by requiring expert validation of the generated ontology before any data ingestion. (b) The narrative-wrap step at query time is stochastic; identical queries return identical Cypher result sets but the natural-language summary may differ across runs—by design, since the summary is a presentation layer rather than a decision artifact, and the underlying Cypher results are what should be cited in after-action review. (c) Newer LLM releases may shift NL→Cypher translation behavior on edge-case phrasings; we therefore recommend that any model upgrade be accompanied by a regression run of the published 20-question evaluation set against the published graph, with a documented diff of the resulting Cypher and result sets.
4.5. Computational Performance
This subsection consolidates the practical-deployment characteristics of ARES-KG across four dimensions: hardware and software environment, latency, on-device footprint, and scalability. All experiments reported in this paper were conducted on a 2021 MacBook Air M1 (Apple Silicon, 8 GB unified memory, 256 GB SSD) running Neo4j Desktop 1.6.1, with LLM access via the claude.ai consumer interface for Claude 3.7 Sonnet (ARES-KG configuration) and via the corresponding consumer web interfaces for GPT-5.5 and Gemini 3 Flash (B2 baseline ablations reported in Section 4.2.5). All computational-performance figures reported below correspond to this configuration.
Latency. The Mean Latency per Query reported in Section 4.2.5 averages approximately 7.5 s end-to-end for the full ARES-KG pipeline—natural-language question → Cypher generation → graph execution → narrative wrap. The dominant component is the language-model call (Cypher generation and narrative wrap together); graph execution for the operational queries described in Section 4.1 is sub-second under the schema constraints described in Section 3 and Section 4.4.
On-device footprint. The Neo4j graph instantiated from the brigade-scenario CSVs has an estimated on-disk footprint of approximately 25 MB and an estimated working-set memory footprint of approximately 1.5 GB under the default Neo4j Community Edition memory configuration (page cache plus JVM heap). Both figures are architectural estimates consistent with the scenario scale (on the order of tens of units, tens of assets, tens of locations, and a few hundred typed relationships) and the storage characteristics of Neo4j Desktop 1.6.1; they are not measurements from a controlled profiling run, and a full profiling study with measured values across multiple scenario sizes is committed to in Section 6. The on-device footprint sits well within the operating envelope of commodity edge hardware and is consistent with deployment on the test machine without observed memory pressure.
Scalability. The framework’s scaling characteristics follow from its architecture rather than from special engineering. Graph construction uses idempotent LOAD CSV … MERGE operations under unique-identifier constraints; ingestion is therefore linear in the number of CSV rows and the rebuild is deterministic. Query latency for the operational questions described in Section 4.1 is dominated by bounded-depth traversal (typically three to four hops) over indexed starting nodes, and is therefore largely independent of total graph size for the scale class characteristic of brigade-level scenarios. We acknowledge that empirical scalability measurements across multiple scenario sizes were not part of this initial evaluation, and a controlled stress test (ingestion time and query latency as functions of graph size) is committed to as a specific deliverable in the multi-scenario evaluation program described in Section 6.
Edge-cloud deployment characteristics. The framework is best described as a hybrid edge-cloud architecture rather than a pure edge deployment. On-device components—Neo4j graph store, schema-locked translation prompt, Cypher execution, idempotent ingestion script, and result rendering—run locally and have the small footprint reported above; no GPU is required on the edge device. LLM inference is delegated to a remote endpoint over the lowest-bandwidth interaction in the pipeline (natural-language question in, generated Cypher and narrative answer out). The on-device portion supports a reset-to-known-state operational mode after disconnection or contamination, since the scenario graph is rebuildable deterministically from CSVs in seconds. Full edge deployment—substitution of the cloud LLM for a locally-hosted, quantized open-weight model—is architecturally supported (the LLM interface is a swappable endpoint) but was not exercised in the present evaluation; it is committed to as a future-work deliverable in Section 6.
4.6. Robustness and Security Considerations
This subsection consolidates the framework’s robustness and security properties under four headings: hallucination resistance, NL→Cypher translation robustness, adversarial-prompt resilience, and security and access-control posture. The first two are supported by empirical and architectural evidence elsewhere in this manuscript; the second two are scoped qualitatively here and identified as deliverables of a forthcoming security evaluation committed to in Section 6.
Hallucination resistance: ARES-KG’s principal hallucination-mitigation mechanism is the schema-locked translation layer described in Section 3 and Section 4.4. The translation prompt fixes the set of admissible labels, relationship names, and identifier conventions, and the LLM cannot emit Cypher that references entities outside the declared schema; any such attempt fails at parse or execution time rather than being returned as fabricated content. Empirically, this property is reflected in the Entity Hallucination Rate (EHR) reported in Section 4.2.5: the full ARES-KG pipeline achieves EHR = 0% across the 20 operational questions, against approximately 4% for the unstructured-baseline configuration (ranging from ~2% for one commercial LLM to ~6% for another), which included specific invented entities not present in the scenario data. Hallucination resistance in ARES-KG therefore derives from architectural construction—the graph as ground truth, schema-locking as the gate—rather than from prompt engineering applied to free-form generation.
NL→Cypher translation robustness: the failure modes of the translation layer are characterized in Section 4.3 (Error Analysis): occasional misparsing of operationally synonymous phrasings, mismatch between user-named entities and canonical scenario identifiers, and approximate handling of counterfactual queries at the prompt level rather than at the graph level. These failures are inspectable (the generated Cypher is exposed to the operator) and recoverable (re-phrasing or operator correction restores intended behavior); they do not produce silent decision drift, since out-of-schema Cypher either parses or fails. The reproducibility properties documented in Section 4.4 (idempotent build, schema-locked translation, deterministic execution against the static graph) and the Cross-LLM Consistency Rate of approximately 1.0 reported in Section 4.2.5 for the full pipeline—compared with 0.20 for the unstructured baseline—provide quantitative evidence that the Cypher generated by ARES-KG is reproducible and resistant to drift across language-model versions and prompt paraphrasings.
Adversarial-prompt resilience: It is acknowledged that the present manuscript does not include a formal adversarial-prompt evaluation. The schema-locking layer narrows the attack surface by restricting the space of admissible Cypher to the declared schema, and read-only execution at the Neo4j role level—recommended as the operational deployment configuration—prevents adversarial Cypher from mutating the graph. However, schema-locking alone does not eliminate prompt-injection risk: an adversarial user-supplied natural-language input could attempt to subvert the translation prompt, induce out-of-domain query generation, or attempt to extract graph contents beyond the user’s intended scope. A controlled adversarial-prompt evaluation, including a red-team suite of prompt-injection, schema-evasion, and graph-exfiltration attempts with measured attack-success rate reported per attack class, is committed to in Section 6 as a specific deliverable of the security evaluation accompanying the multi-scenario program.
Security and access-control posture: the present implementation operates in a single-user, single-graph configuration, with all generated Cypher exposed for inspection and audit by the operator. Three operational security considerations apply to any production deployment and are identified explicitly in Section 6 as deliverables of a forthcoming security analysis. First, multi-user deployment requires user-level role-based access control at the Neo4j layer, restricting which subgraphs or relations each user can query; this is supported natively by Neo4j Community Edition. Second, every NL→Cypher invocation should be logged with its prompt, generated Cypher, result set, and narrative wrap, supporting after-action audit and forensic review of any contested decision. Third, in the present hybrid edge-cloud configuration described in Section 4.5, the operational data submitted to the cloud LLM endpoint (the natural-language question and the schema fragments included in the prompt) is exposed to the LLM provider; this exposure is mitigated by the local-LLM migration committed to in Section 6, which removes the cloud dependency at query time and confines all operational data to the edge device.
5. Discussion
This study shows that KGs add a qualitatively new capability to operational analytics: they externalize structure and causality in a form that is both computable and inspectable. Traditional dashboards and tabular pipelines surface snapshots and aggregates; they rarely encode why an effect occurs or how it will propagate. By contrast, an ontology-grounded KG makes dependencies first-class objects—e.g., Bridge Alpha → BLOCKS_ROUTE → Route X → LIMITS_MOBILITY_OF → U02 → DELAYS → Mission Sentinel. Once such chains are explicit, the system can trace second- and third-order effects, explore qualitative counterfactual scenarios via virtual edge removal without mutating the underlying graph, and return answers with provenance (“which nodes, edges, and properties led to this conclusion”). This representational shift matters because many operational failures are not the result of missing facts but of unseen interdependencies across sustainment, maneuver, fires, ISR, and C2. Humans routinely miss these multi-hop interactions under time pressure; the graph does not.
Taken together, the results suggest a balanced picture of where ARES-KG delivers the most value and how it translates into battlefield effectiveness. The pipeline is best suited to planning staffs and higher-echelon commanders contending with multi-domain coordination, where explicit dependencies and causal effects matter most; for rapid, small-unit tactics, simpler methods may remain appropriate. In brigade-level vignettes, the KG consistently improved multi-echelon coordination (across 12 units with complex command ties), resource optimization over 15 strategic assets, impact assessment for infrastructure targeting, and real-time situational awareness across 14 tactical locations. Crucially, the approach exposes hidden dependencies that traditional tools obscure: queries reveal, for example, that destroying Bridge Alpha would immediately affect multiple eastern units, or that specific communications nodes are single-threaded chokepoints for mission continuity. Its vulnerability analysis is operationally consequential—flagging that a Fuel Depot compromise would degrade sustainment, a UAV loss would create surveillance blind spots, and a Route X interdiction would force costly reroutes—thereby enabling pre-emptive mitigation instead of reactive recovery. Finally, the dual Neo4j/TTL architecture provides immediate tactical utility while preserving semantic-web interoperability, positioning organizations to adopt emerging standards without sacrificing current operational effectiveness.
KGs also surface patterns that are cognitively expensive for staff to discover in the moment. Examples include single-point failures hidden in mixed ownership (a low-profile comm relay that gates multiple missions), underutilized assets whose effects do not align with current priority (fires with potential coverage but no tasking), and latent chokepoints where terrain, weather, and logistics intersect to create brittle plans. None of these insights requires new data; they require relational composition of existing data at query time. Encoding the scenario as nodes and typed edges enables such composition to be automated, repeatable, and auditable—something that spreadsheets, ad-hoc scripts, or free-text reports cannot reliably deliver.
The synergy between KGs and LLMs is therefore more than convenience; it is capability creating. The KG provides grounding, schema, and causal semantics; the LLM supplies translation (NL→Cypher), hypothesis scaffolding (what-if templates), and narrative explanation (“so-what” summaries) over the same, governed substrate. This pairing closes the loop between human intent and machine execution: a commander expresses an operational question in natural language; the LLM emits a schema-aware, auditable query; the KG executes over explicit dependencies; and the LLM renders a concise operational brief tied to the graph evidence. The result is neither a black box (because every step is inspectable) nor a manual tool (because translation and stitching are automated). In practice, this loop reduced time-to-insight while increasing trust, since users could click through from prose to paths.
For military stakeholders, the implications are concrete. First, tempo and foresight: causal edges allow rapid estimation of downstream impacts (e.g., route interdiction → resupply slip → mission risk) and support preemptive mitigation (alternate bridging, forward caching, comms redundancy). Second, explainability and governance: each recommendation carries a traceable path through doctrine-aligned concepts (Unit, Mission, Asset, Location), easing briefing, review, and after-action accountability. Third, deployment footprint: the on-device CSV→Neo4j→NL interface is lightweight and rebuildable from files. In the present implementation, LLM inference is delegated to a remote endpoint, making the system a hybrid edge-cloud architecture (Section 4.5); full operation in disconnected, intermittent, low-bandwidth environments is a near-term goal contingent on the local-LLM migration committed to in Section 6. Fourth, human factors: operators keep decision authority while delegating graph traversal and bookkeeping to the machine; this reduces cognitive load without removing judgment. Finally, safety: by constraining the LLM to a known schema and case-sensitive identifiers, the system curbs hallucination and ensures outputs remain within scenario bounds.
The human–AI comparison sharpens this picture. Under the eight-dimensional rubric, within the present ten-officer sample, the ARES-KG–enabled LLM scored above every second Lieutenant and above the weakest Captain, and clustered with the Majors and Lieutenant Colonels in overall Decision Support Score. Qualitatively, the agent’s strengths align with the structure of the graph: it rarely misses relevant units, assets, or missions (D1), reasons systematically about mobility corridors and sustainment chains (D2–D3), and articulates long, explicit causal chains from disruptions to mission impact (D5), all while remaining doctrinally safe (D8). These are precisely the dimensions where humans are most likely to overlook multi-hop dependencies under time pressure. The main gaps compared with the strongest officers appear in C2 robustness (D4), where experienced commanders leverage implicit doctrine, habitual coordination patterns and tacit “pattern recognition” that are not yet encoded in the KG. This suggests a complementary role: ARES-KG excels at exhaustive, schema-level reasoning over the space of possibilities, while senior officers remain better at imposing a coherent command scheme and nuanced risk posture.
The same properties transfer to adjacent high-stakes domains, notably border and coast-guard security. There, entities map naturally to patrol units, ports of entry, vessels, radars, UAVs, interdiction corridors, and risk indicators; causal relations map to weather/sea-state effects, sensor coverage gaps, supply/maintenance readiness, and cross-agency dependencies. A KG can unify operational pictures across agencies, while the LLM enables officers to ask mission questions directly (“which patrol patterns leave Sector Delta blind under Beaufort 6?”, “what are the cascading effects if Radar Bravo is down during surge traffic?”). As in the military case, the outcome is faster, more defensible action with clear provenance, improved coordination, and reduced likelihood that a local outage or delay propagates system-wide.
From a human factors perspective, the key result is not that ARES-KG “beats” or “matches” experts, but that it delivers near-expert decision-support at a fundamentally different tempo. The same rubric score that a Major or Colonel achieves after careful reading, synthesis and note-taking is reached by the LLM–KG pipeline in seconds, because graph traversal and bookkeeping are automated. This changes how staff can use their time: instead of manually assembling dependencies, they can query, critique and adapt machine-generated options. In practice, ARES-KG is best interpreted as an assistant that lifts the floor of staff work—bringing junior or over-loaded cells closer to expert-level causal reasoning—while still leaving final judgment, prioritization, and C2 design in human hands.
In sum, KGs contribute the missing grammar of operations—typed entities, explicit relations, and named causal effects—while LLMs contribute a fluent, auditable interface that turns that grammar into timely decisions. Together they convert scattered operational data into a living, explainable model of the battlespace (or border space), enabling commanders and coordinators to see beyond the immediate symptom and act on the underlying structure. This is not merely incremental analytics; it is a change in the unit of reasoning—from rows and charts to paths and causes—and it demonstrably improves both speed and quality of decisions in complex, time-critical environments.
Comparison with Recent LLM–KG Hybrid Systems
To position ARES-KG within the current state of the art, we provide a focused comparison against the principal threads of recent work on LLM–KG hybridization, grouped along six dimensions that bear on operational decision support.
Causal semantics. Existing LLM–KG hybrids primarily treat the KG as a factual lookup layer: retrieval-augmented approaches surveyed by Kau et al. [12] and Khorashadizadeh et al. [13] retrieve passages or subgraphs to ground LLM generation, but the graph itself does not carry typed causal semantics. Yao et al. [20] and similar factual-grounding approaches improve answer correctness but do not provide multi-order effect tracing. ARES-KG advances this thread by elevating directed influence relations (BLOCKS_ROUTE, LIMITS_MOBILITY_OF, ENABLES_SURVEILLANCE, DELAYS, etc.) to first-class queryable edges, enabling deterministic graph-traversal counterfactuals rather than free-form LLM-mediated causal speculation; the ablation reported in Section 4.2.5 (CCR 0.20 → 1.0; EHR 4% → 0%; DSS 70.8 → 95.8) quantifies the operational gain. The closest comparable work—Ao et al. [18] on causal-enhanced reasoning—operates in static or simulated contexts and does not address provenance tracking or human interpretability in live applications.
Schema-locking and grounding mechanism. Most retrieval-augmented LLM–KG hybrids use prompt-time retrieval as the primary grounding mechanism, which constrains content but not generation form: the LLM can still produce malformed queries or reference entities outside the retrieved scope. ARES-KG instead implements schema-locking at the translation prompt—the LLM cannot emit Cypher referencing labels, relationships, or identifiers outside the declared schema—converting grounding from a soft constraint into a hard one. The Entity Hallucination Rate of 0% reported in Section 4.2.5, against 4% for an LLM operating on the same data without schema-locking, is direct evidence of the strength of this mechanism.
Multi-hop reasoning depth. Recent work such as Dai et al. [19] and the QA-GNN architecture of Yasunaga et al. [16], addresses multi-hop reasoning through learned graph traversal or message passing. ARES-KG uses a structurally simpler mechanism—explicit Cypher traversal over bounded-depth paths—that is auditable, reproducible across LLM versions, and operationally interpretable; it trades the expressive flexibility of learned traversal for transparency and deterministic execution. For decision-support tasks where after-action audit is mandatory, this trade is favorable; for tasks requiring inductive generalization beyond the encoded ontology, learned traversal approaches remain better suited.
Decision-support orientation versus question answering. Most LLM–KG hybrids reported in the literature target question answering over factoid or domain-knowledge benchmarks. ARES-KG is decision-oriented: each output couples a structured query result with a narrative “so-what” tying the finding to a concrete operational decision, and the evaluation rubric (Section 4.2.1) measures decision-support quality across eight operational dimensions rather than factoid correctness. This makes ARES-KG less directly comparable to standard QA-benchmark numbers but more comparable to expert human reasoning, which is why we structured the evaluation as a head-to-head human–AI comparison.
Evaluation methodology. ARES-KG’s evaluation methodology—human–AI head-to-head on a structured rubric, with rank-and-corps-stratified human comparators—differs from the standard automated-benchmark evaluation of most LLM–KG hybrid work. We treat this as a strength for the safety-critical decision-support setting, where benchmark accuracy does not capture the operational quality of a recommendation; we acknowledge that it limits direct comparability to systems evaluated on standard QA or KGQA benchmarks. Cross-benchmark evaluation on standard KGQA datasets is identified as a longer-horizon comparative-benchmarking step in Section 6.
Operational deployment readiness. Most LLM–KG hybrids in the literature remain research prototypes evaluated under controlled conditions. ARES-KG explicitly addresses deployment characteristics—schema-locked reproducibility (Section 4.4), hybrid edge-cloud computational footprint (Section 4.5), security and access-control posture (Section 4.6), and operational-deployment constraints (Section 4.3)—that are typically out of scope for benchmark-oriented work. We acknowledge that the present implementation has not been fielded operationally and that several of these properties (particularly local-LLM hosting and rugged-edge deployment) remain future-work commitments rather than demonstrated capabilities.
In summary, ARES-KG is positioned within the LLM–KG hybridization space as a deployment-oriented framework that prioritizes deterministic auditability, explicit causal semantics, and schema-locked grounding over the expressive flexibility of learned graph-reasoning approaches. The comparison above shows where this trade is favorable for safety-critical decision support and where alternative approaches (learned multi-hop reasoning, factual-grounding hybrids) remain better suited.
6. Conclusions
This work introduced ARES-KG, a unified, ontology-driven pipeline that fuses the structure and causal semantics of knowledge graphs with the natural-language fluency and translation capabilities of large language models. At the core of this pipeline is a single methodological commitment—treating causal dependencies as first-class, queryable graph relations—and the remaining elements of the framework (the NL→Cypher loop, the CSV→Neo4j build process, and the human–AI rubric) are presented respectively as the access mechanism, the engineering enabler, and the empirical evidence for this central claim. Starting from operational CSVs, the pipeline (i) models the mission space with an explicitly causal ontology, (ii) deterministically materializes a Neo4j graph, and (iii) translates commander questions from natural language into auditable Cypher that returns both graph evidence and concise “so-what” narratives. In a synthetic but realistic tactical vignette, ARES-KG consistently exposed multi-hop dependencies (e.g., route interdictions cascading into mobility and sustainment delays), ranked critical C2 nodes, surfaced reinforcement options under time and terrain constraints, and supported qualitative counterfactual ‘what-if’ reasoning via virtual edge removal (in the doctrinal sense defined in Section 3, not in the formal-causal sense)—capabilities that are difficult to achieve with spreadsheets, static dashboards, or black-box models alone. The key contribution is not a single algorithm but a closed, inspectable human–AI loop: every answer is grounded in typed entities and named relations, every query is reproducible, and every recommendation carries provenance. Practically, this reduced time-to-insight while increasing trust and explainability—two properties central to high-stakes decision making. Our human–AI comparison reinforces this conclusion. In the provided scenario, and within the present ten-officer sample, the ARES-KG pipeline achieved a Decision Support Score at the field-grade rank-group mean and above every junior officer in the sample on an eight-dimensional rubric, while answering orders of magnitude faster. These findings suggest that hybrid LL-KG agents can act as near-expert staff assistants that raise the baseline quality and tempo of operational analysis, provided they are embedded within doctrine-aware command structures and used to augment, rather than replace, human judgment.
The immediate next step for ARES-KG is a structured multi-scenario evaluation program designed to test the generalizability of the architecture across the defense operational space. Within this program, the ontology and causal-relation vocabulary will be held fixed while scenario-instance data varies, allowing a cross-scenario ablation that directly measures the portability of the framework. The first two extensions target border-security operations (extending the entity set to patrols, checkpoints, sensors, vessels, and interdiction corridors, with causal relations covering sensor coverage gaps, weather/sea-state effects, and cross-agency dependencies) and search-and-rescue operations (extending to victim locations, rescue assets, environmental hazards, and time-critical resource allocation). The multi-scenario evaluation program will also expand the human comparator pool to at least 30 active-duty officers across at least two operational units, with each response independently scored by two raters to permit formal measurement of inter-rater reliability (Cohen’s κ on each of the eight rubric dimensions) and the reporting of confidence intervals on per-rank DSS means.
Three computational-performance commitments accompany the multi-scenario program. First, a controlled scalability stress test will be conducted across at least three scenario sizes (brigade, division, and corps order-of-magnitude scales), measuring ingestion time and query latency as functions of graph size and reporting whether the bounded-depth-traversal property described in Section 4.5 holds across the scale range. Second, the LLM component will be migrated from the consumer-interface configuration used in the present implementation to a locally-hosted, quantized open-weight model (e.g., a 7B-class instruction-tuned model served via Ollama or a comparable local inference runtime), enabling true edge deployment with no cloud dependency at query time. Third, the resulting locally-hosted configuration will be benchmarked on representative rugged-edge hardware (for example, a tactical-grade tablet or ruggedized laptop) under intermittent and fully disconnected operating conditions, with measured latency, memory footprint, and answer quality reported against the present cloud-LLM baseline.
Beyond multi-scenario evaluation within defense, four longer-horizon research directions are envisaged. (i) The pipeline will incorporate uncertainty-aware reasoning—confidence values on observations, edge strengths on causal relations, and probabilistic propagation through traversals—so that outputs express bounded risk rather than only point estimates. (ii) Evaluation will be conducted with operational stakeholders on real (non-synthetic) tasks under controlled conditions, to measure decision latency, accuracy, and trust against operational ground truth rather than research-team-authored ground truth. (iii) The natural-language layer will be extended to support multi-language operation (Greek and English in the first instance), enabling deployment in coalition and multinational settings where the language of instruction varies across staff. (iv) Adjacent non-defense high-stakes domains—civil emergency response, critical-infrastructure protection, and humanitarian logistics—will be explored as longer-horizon transfer targets, contingent on the success of the within-defense multi-scenario program.
Author Contributions
Conceptualization, D.D. and K.K.; methodology, D.D.; software, D.D.; validation, D.D.; formal analysis, D.D.; investigation, D.D.; resources, D.D.; data curation, D.D.; writing—original draft preparation, D.D.; writing—review and editing, D.D. and K.K.; visualization, D.D.; supervision, K.K.; project administration, D.D.; All authors have read and agreed to the published version of the manuscript.
Funding
This research received no external funding.
Institutional Review Board Statement
Not applicable.
Informed Consent Statement
Not applicable.
Data Availability Statement
The data presented in this study are openly available in: https://github.com/dimitrisdoumanas19/DSS-ARESKG (accessed on 14 May 2026).
Acknowledgments
The authors would like to thank the anonymous colleagues who contributed to this study by participating in the evaluation process as human decision-makers, providing an essential comparative baseline. GenAI tools were used exclusively for research purposes within the ARES-KG pipeline, not for manuscript writing or editing. Specifically: (1) OpenAI ChatGPT 5.0 was used to generate the initial OWL/Turtle ontology from the scenario CSV schemas, following a structured prompt that constrained the model to the provided data and modeling requirements; the resulting ontology was validated in Protégé and refined iteratively by the authors. (2) Anthropic Claude 3.7 Sonnet was used to auto-generate the Neo4j Cypher ingestion script for KG construction from CSV, and to perform natural-language-to-Cypher query translation during the NL→Cypher evaluation phase. All generated Cypher queries were verified by the authors against the graph schema in Neo4j Browser before use. In all cases, GenAI outputs were treated as drafts subject to expert review and correction, and the authors take full responsibility for the final content.
Conflicts of Interest
The authors declare no conflicts of interest.
Abbreviations
The following abbreviations are used in this manuscript:
| ARES-KG | Actionable & Reasoned Edge Support over Knowledge Graphs |
| KGs | Knowledge Graphs |
| LLMs | Large Language Models |
| AI | Artificial Intelligence |
| NL | Natural Language |
| NLP | Natural Language Processing |
| DSS | Decision Support Score |
| CQ | Competency Question |
| ISR | Intelligence, Surveillance, and Reconnaissance |
| UAV | Unmanned Aerial Vehicle |
| LOS | Line of Sight |
| FOB | Forward Operating Base |
| APC | Armored Personnel Carrier |
| C2 | Command and Control |
Appendix A
“You are an expert military ontology engineer and OWL/Turtle modeler. Produce a compact, operationally useful ontology for ARES-KG (Actionable & Reasoned Edge Support over KGs) from the attached CSVs only. The scenario is entirely hypothetical and not based on real events or real units. Do not rely on prior training data, external memory, or outside sources; ground every class, datatype property, object property, and relation strictly in the attached CSV headers and the instructions here. Do not invent entities, attributes, or relations that are not evidenced by the CSVs or the relation list. Treat all identifiers as case-sensitive and consistent (e.g., U01, not Uo1) and preserve the provided label spellings. Include the following verbatim in the owl:Ontology header as Aim & Scope. Aim: Provide a minimal, operational ontology that supports real-time decision-making via explicit modeling of units, missions, assets, terrain, mobility, communications, sustainment, and causal effects relevant to battlefield operations. Scope: Tactical/operational level; entities include Units, Assets, Locations, Missions, Comm Nodes, Mobility assets, and n-ary operational events (SupplyRequirement, Disruption, Location–Mobility Effect). Relations include task organization, placement, sustainment, communications support, mobility effects, and named causal impacts (e.g., BLOCKS_ROUTE, ENABLES_SURVEILLANCE). Model only what appears in the CSV headers and the relation list. Output a single, valid Turtle (.ttl) ontology that declares the necessary classes and properties directly implied by the CSVs, with sensible ranges for scalar fields (integers, booleans, strings) and object properties for the foreign-key style columns; ensure the ontology loads without errors in Protégé and contains no speculative terms”.
Appendix B
This appendix reproduces the five operational walkthroughs that illustrate how ARES-KG converts natural-language operational questions into executable Cypher queries, returned graph results, and concise operational narratives. The walkthroughs are intentionally heterogeneous, spanning sustainment-chain tracing (Example 1), fires deconfliction (Example 2), mobility–weather coupling (Example 3), counterfactual analysis under enemy retrograde (Example 4), and C2 criticality with multi-hop traversal (Example 5), so that the principal categories of operational reasoning supported by the framework are illustrated end-to-end. Each walkthrough was generated by the schema-locked NL→Cypher pipeline described in Section 4.1, executed against the ARES-KG instance constructed for the brigade-level defensive scenario described therein.
- Example 1—Query 4: “What are the downstream effects of a failed resupply to Base Camp East?”
The query over the sustainment layer returns two missions immediately exposed to a miss at the base hub: India Logistics—“Supply Run Beta” (readiness 55; low threat) and Golf Engineers—“Engineering Support” (readiness 70; low threat). Although both missions are tagged low priority, their shared dependency on Base Camp East makes the effect operationally significant: delays extend the period in which maneuver elements operate on fragile lines of communication and postpone route hardening/repairs. The actionable implication is logistical rather than tactical—pre-position limited fuel/parts from alternate depots, reroute via Bridge Beta if Route X is constrained, and schedule a protected night convoy—to neutralize a single-point vulnerability while preserving overall tempo.
- Example 2—Query 5: “Which artillery assets have line of sight to Sector Echo?”
The line-of-sight query returns Artillery-2 positioned at Ridge 203 with High LOS and confirmed coverage of Sector Echo, and Artillery Fox at Western Ridge with High LOS but only potential coverage. Operationally, this separation between confirmed and potential coverage is decisive for the fire plan: Artillery-2 is the immediate on-call shooter for the sector (register target reference points, allocate priority of fire, and ensure ammunition upload), while Artillery Fox is best postured as a counter-mass/reserve battery pending confirmation (e.g., a quick survey update or observer check) or as a backstop if Artillery-2 is disrupted. The result also cues deconfliction of trajectories and communications links, since a single confirmed battery implies a narrower redundancy margin; establishing a secondary fire channel for Artillery Fox converts a single-threaded fires dependency into a resilient pair, reducing time-to-fires and mitigating risk of coverage loss under maneuver or weather change.
- Example 3—Query 12: “If weather conditions worsen, which mobility-dependent units are impacted?”
The weather–mobility sensitivity query identifies Alpha Company and Bravo Platoon operating in Sector East under Foggy conditions on Mixed terrain (readiness 95 and 60, respectively). This result indicates that maneuver windows for both elements narrow as visibility and trafficability degrade, with a higher risk of schedule slippage for Bravo Platoon due to lower readiness. The immediate planning implication is to adjust timing and routing for ground movement, pre-allocate alternate mobility (e.g., APC lift) where feasible, and shift ISR tasking toward sensors less affected by fog (UAV/radar handoff) to preserve reconnaissance and fire control. By linking meteorological state to unit posture, the graph provides a defensible basis for revising the synchronization matrix before mobility degradation propagates into missed mission timings.
- Example 4—Query 16: “If an enemy retreat is detected, what flanking options open up?”
Recomputing reachable terrain under a retreat counterfactual returns Alpha Company and Delta Recon as the formations with the strongest flanking potential, reflecting favorable line-of-sight and current readiness (95 and 90, respectively) from Sector East and Route X. Operationally, this supports an immediate transition from defense to exploitation: Alpha Company is suited to execute the primary flanking maneuver, while Delta Recon screens and secures avenues of approach, with fires and logistics aligned to the emergent axis. The result underwrites a rapid commander’s decision—commit to pursuit or contain—by quantifying which forces can convert the adversary’s retrograde into positional advantage without overextending sustainment or C2 coverage.
- Example 5—Query 18: “What communications nodes are most critical for mission continuity?”
By traversing CommNode → Unit → Mission, counting distinct missions per node, and ranking the results, the graph surfaces a compact set of C2 chokepoints—Relay R-5, Net Hub 7, Satellite Link Bravo, Field Radio Charlie, Comm Station Delta, and Repeater Echo—each currently supporting at least one active mission (e.g., Mission Sentinel, Mission Viper, Fire Support Charlie, Patrol Delta, Operation Flanker, Recon Alpha). Although the missionCount values in this snapshot are low, the implication is a single-threaded dependency: loss or degradation of any listed node would immediately impair the named mission’s command and control. The appropriate action is preventive hardening and redundancy: duplicate links (primary/alternate routing), stage spare power and antennas forward, schedule periodic link-health checks, and pre-assign fallback paths so that a node failure triggers an automatic switchover without interrupting mission execution. This converts brittle point dependencies into resilient C2 fabrics and reduces the likelihood that a local outage propagates into mission delay or abort.
References
- Chang, Y.; Wang, X.; Wang, J.; Wu, Y.; Yang, L.; Zhu, K.; Chen, H.; Yi, X.; Wang, C.; Wang, Y.; et al. A Survey on Evaluation of Large Language Models. ACM Trans. Intell. Syst. Technol. 2024, 15, 1–45. [Google Scholar] [CrossRef] [Scilit]
- Shang, W.; Huang, X. A Survey of Large Language Models on Generative Graph Analytics: Query, Learning, and Applications. IEEE Trans. Knowl. Data Eng. 2025, 37, 6799–6819. [Google Scholar] [CrossRef] [Scilit]
- Zhu, Y.; Wang, X.; Chen, J.; Qiao, S.; Ou, Y.; Yao, Y.; Deng, S.; Chen, H.; Zhang, N. Llms for knowledge graph construction and reasoning: Recent capabilities and future opportunities. World Wide Web 2024, 27, 58. [Google Scholar] [CrossRef] [Scilit]
- Svoboda, I.; Lande, D. Enhancing Multi-Criteria Decision Analysis with AI: Integrating Analytic Hierarchy Process and GPT-4 for Automated Decision Support. arXiv 2024, arXiv:2402.07404. [Google Scholar]
- Hogan, A.; Blomqvist, E.; Cochez, M.; D’amato, C.; Melo, G.D.; Gutierrez, C.; Kirrane, S.; Gayo, J.E.L.; Navigli, R.; Neumaier, S.; et al. Knowledge Graphs. ACM Comput. Surv. 2022, 54, 1–37. [Google Scholar] [CrossRef] [Scilit]
- Angelis, S.; Moraitou, E.; Caridakis, G.; Kotis, K. CHEKG: A collaborative and hybrid methodology for engineering modular and fair domain-specific knowledge graphs. Knowl. Inf. Syst. 2024, 66, 4899–4925. [Google Scholar] [CrossRef] [Scilit]
- Baldazzi, T.; Bellomarini, L.; Ceri, S.; Colombo, A.; Gentili, A.; Sallinger, E.; Atzeni, P. Explaining Enterprise Knowledge Graphs with Large Language Models and Ontological Reasoning. In The Provenance of Elegance in Computation—Essays Dedicated to Val Tannen; Schloss Dagstuhl—Leibniz-Zentrum für Informatik: Wadern, Germany, 2024; pp. 1:1–1:20. [Google Scholar] [CrossRef]
- Feng, C.; Zhang, X.; Fei, Z. Knowledge Solver: Teaching LLMs to Search for Domain Knowledge from Knowledge Graphs. arXiv 2023, arXiv:2309.03118. [Google Scholar] [CrossRef] [Scilit]
- Ibrahim, N.; Aboulela, S.; Ibrahim, A.; Kashef, R. A survey on augmenting knowledge graphs (KGs) with large language models (LLMs): Models, evaluation metrics, benchmarks, and challenges. Discov. Artif. Intell. 2024, 4, 76. [Google Scholar] [CrossRef] [Scilit]
- Doumanas, D.; Ntalouka, E.; Vassilakis, C.; Wallace, M.; Kotis, K. Stitching History into Semantics: LLM-Supported Knowledge Graph Engineering for 19th-Century Greek Bookbinding. Mach. Learn. Knowl. Extr. 2025, 7, 59. [Google Scholar] [CrossRef] [Scilit]
- Pan, S.; Luo, L.; Wang, Y.; Chen, C.; Wang, J.; Wu, X. Unifying Large Language Models and Knowledge Graphs: A Roadmap. IEEE Trans. Knowl. Data Eng. 2024, 36, 3580–3599. [Google Scholar] [CrossRef] [Scilit]
- Kau, A.; He, X.; Nambissan, A.; Astudillo, A.; Yin, H.; Aryani, A. Combining Knowledge Graphs and Large Language Models. arXiv 2024, arXiv:2407.06564. [Google Scholar]
- Khorashadizadeh, H.; Amara, F.Z.; Ezzabady, M.; Ieng, F.; Tiwari, S.; Mihindukulasooriya, N.; Groppe, J.; Sahri, S.; Benamara, F.; Groppe, S. Research Trends for the Interplay between Large Language Models and Knowledge Graphs. arXiv 2024, arXiv:2406.08223. [Google Scholar] [CrossRef] [Scilit]
- Li, D.; Xu, F. Synergizing Knowledge Graphs with Large Language Models: A Comprehensive Review and Future Prospects. arXiv 2024, arXiv:2407.18470. [Google Scholar]
- Lavrinovics, E.; Biswas, R.; Bjerva, J.; Hose, K. Knowledge Graphs, Large Language Models, and Hallucinations: An NLP Perspective. J. Web Semant. 2025, 85, 100844. [Google Scholar] [CrossRef] [Scilit]
- Yasunaga, M.; Ren, H.; Bosselut, A.; Liang, P.; Leskovec, J. QA-GNN: Reasoning with Language Models and Knowledge Graphs for Question Answering. arXiv 2022, arXiv:2104.06378. [Google Scholar] [CrossRef] [Scilit]
- Tan, X.; Wang, X.; Liu, Q.; Xu, X.; Yuan, X.; Zhang, W. Paths-over-Graph: Knowledge Graph Empowered Large Language Model Reasoning. In Proceedings of the ACM on Web Conference 2025, Sydney, NSW, Australia, 28 April–2 May 2025; ACM: New York, NY, USA, 2025; pp. 3505–3522. [Google Scholar]
- Ao, T.; Yu, Y.; Wang, Y.; Deng, Y.; Guo, Z.; Pang, L.; Wang, P.; Chua, T.-S.; Zhang, X.; Cai, Z. LightPROF: A Lightweight Reasoning Framework for Large Language Model on Knowledge Graph. arXiv 2025, arXiv:2504.03137. [Google Scholar]
- Dai, X.; Hua, Y.; Wu, T.; Sheng, Y.; Ji, Q.; Qi, G. Large language models can better understand knowledge graphs than we thought. Knowl.-Based Syst. 2025, 312, 113060. [Google Scholar] [CrossRef] [Scilit]
- Yao, L.; Peng, J.; Mao, C.; Luo, Y. Exploring Large Language Models for Knowledge Graph Completion. In Proceedings of the ICASSP 2025—2025 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), Hyderabad, India, 6–11 April 2025; IEEE: Piscataway, NJ, USA, 2025; pp. 1–5. [Google Scholar] [CrossRef] [Scilit]
- Bai, X.; He, S.; Li, Y.; Xie, Y.; Zhang, X.; Du, W.; Li, J.-R. Construction of a knowledge graph for framework material enabled by large language models and its application. npj Comput. Mater. 2025, 11, 51. [Google Scholar] [CrossRef] [Scilit]
- Gao, Y.; Li, R.; Croxford, E.; Caskey, J.; Patterson, B.W.; Churpek, M.; Miller, T.; Dligach, D.; Afshar, M. Leveraging Medical Knowledge Graphs Into Large Language Models for Diagnosis Prediction: Design and Application Study. JMIR AI 2025, 4, e58670. [Google Scholar] [CrossRef] [Scilit] [PubMed]
- Matsumoto, N.; Choi, H.; Moran, J.; Hernandez, M.E.; Venkatesan, M.; Li, X.; Chang, J.-H.; Wang, P.; Moore, J.H. ESCARGOT: An AI agent leveraging large language models, dynamic graph of thoughts, and biomedical knowledge graphs for enhanced reasoning. Bioinformatics 2025, 41, btaf031. [Google Scholar] [CrossRef] [Scilit] [PubMed]
- Zhang, M.; Kuang, M.; Shi, H.; Zhu, J.; Zhu, J.; Jiang, X. Command-agent: Reconstructing warfare simulation and command decision-making using large language models. Def. Technol. 2026, 56, 294–313. [Google Scholar] [CrossRef] [Scilit]
- Liu, X.; Mao, T.; Shi, Y.; Ren, Y. Overview of knowledge reasoning for knowledge graph. Neurocomputing 2024, 585, 127571. [Google Scholar] [CrossRef] [Scilit]
- Pearl, J. Causality: Models, Reasoning and Inference; Guide Books; Cambridge University Press: New York, NY, USA, 2009; Available online: https://dl.acm.org/doi/book/10.5555/1642718 (accessed on 16 May 2026).
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license.





