Knowledge-Defined Networking (KDN)

• Knowledge-Defined Networking (KDN) is a paradigm that combines centralized SDN control with AI-driven analytics to automate network management and optimize routing and resource use.
• KDN employs a feedback loop across data, control, management, and knowledge planes, utilizing machine learning methods to enhance performance and decision-making.
• Implementations of KDN have demonstrated measurable improvements in latency, throughput, and semantic fidelity in applications ranging from 6G networks to smart-city and industrial systems.

Knowledge-Defined Networking (KDN) is a networking paradigm that integrates AI, especially ML, with Software-Defined Networking (SDN) and Network Analytics (NA) to automate, optimize, and transform network control and management. In its foundational formulation, KDN operationalizes the earlier Knowledge Plane idea by combining centralized programmability, rich telemetry, and learning-based reasoning in a feedback loop spanning data, control, management, and knowledge planes (Mestres et al., 2016). Subsequent research has extended this core model through knowledge graphs, semantic interfaces, digital twins, zero-shot policy matching, and unified knowledge services for agentic systems, turning KDN from a conceptual architecture into a broader family of knowledge-driven network management systems (Bilen et al., 27 Sep 2025, Tang et al., 10 Jul 2025).

1. Origins and conceptual scope

The immediate antecedent of KDN is the Knowledge Plane proposed by D. Clark et al., together with earlier attempts to apply AI techniques to network operation and control. The foundational KDN paper argues that these techniques had not been extensively prototyped or deployed because networks are distributed systems in which each node has only local view and control, while earlier environments lacked a global, real-time view of the network and lacked efficient mechanisms to collect, store, and process the data required for learning and control (Mestres et al., 2016).

KDN is therefore defined not as an isolated optimization module, but as a paradigm that accommodates and exploits SDN, NA, and AI. SDN contributes logically centralized control and programmable update of network behavior through southbound imperative interfaces; NA contributes centralized collection, storage, and processing of packet, flow, device, network, historical, and service-level telemetry; and AI contributes supervised, unsupervised, and reinforcement-learning methods for automation, optimization, validation, estimation, recommendation, and improvement (Mestres et al., 2016).

A related line of work, Knowledge Centric Networking (KCN), places knowledge “at the center of the networking landscape” and emphasizes in-network knowledge generation, distribution, storage, and processing. KCN also introduces a hierarchical knowledge structure and exchange styles termed Knowledge as a Tool (KaaT), Knowledge as a Service (KaaS), and Knowledge as a Cloud (KaaC), thereby broadening the scope from single-domain control to potentially heterogeneous cross-domain settings (Charalambides et al., 2020). This suggests that KDN and KCN are closely aligned in their treatment of knowledge as a first-class networking primitive, even when their terminologies and architectural emphases differ.

2. Architectural model and control loop

The canonical KDN architecture consists of four planes. The data plane forwards and processes packets at the fastest timescale; the control plane maintains and updates forwarding rules with logically centralized control; the management plane handles topological configuration, management, and network analytics; and the knowledge plane sits atop the others, leveraging ML and AI to learn, reason, and automate or support network control (Mestres et al., 2016).

The operational loop is explicitly feedback-driven. Forwarding elements export telemetry and state to an analytics platform; ML or DL algorithms learn models, correlations, or policies from current and historical data; the knowledge plane expresses high-level decisions in a declarative, intent-driven language; the SDN controller translates that intent into imperative instructions; and forwarding elements apply the resulting policies, closing the loop (Mestres et al., 2016). The same paper distinguishes closed-loop applications, in which the knowledge plane enacts decisions automatically, from open-loop applications, in which a human operator remains in charge but uses the knowledge plane for validated recommendations, what-if analysis, and performance estimation (Mestres et al., 2016).

Later systems preserve this logic while varying the placement and internal structure of the knowledge plane. In swarm networking, a Dynamic Knowledge Graph (DKG) is introduced between the control and application planes, where it acts as a unified network data view over topology, flow rules, host information, switch information, link status, and in-band network telemetry (INT) data (Guo et al., 2024). In cognitive routing, Intelligent Routing as a Service (iRaaS) is positioned at the application plane above the knowledge plane in a KDN stack, consuming heuristic parameters from trained models while remaining platform- and vendor-agnostic with existing network infrastructures (Ghosh et al., 2024). In 6G management, a five-plane arrangement—Data Plane, Digital Twin Layer, Knowledge Plane, Management Plane, and Control Plane—extends the basic KDN pattern with proactive forecasting and zero-shot policy matching (Bilen et al., 27 Sep 2025).

3. Knowledge representation, semantics, and reasoning

One major line of KDN research treats knowledge not merely as model parameters, but as an explicit semantic artifact. Seer exemplifies this view by organizing the lifecycle into knowledge extraction, knowledge exchange, and knowledge utilisation. Its architecture includes data or information extraction, data distribution, data analytics, knowledge dissemination, and knowledge-driven control, with a first prototype built from Apache Spark for streaming analytics and the ONOS controller for real-time network programming (Sideris et al., 2016). In Seer’s smart-city mobility application, handover events are collected by ONOS, sent through Kafka, processed by Spark Streaming, stored in Cassandra, and exposed through RESTful APIs so that the controller can pre-allocate flows toward the most likely next access point (Sideris et al., 2016).

A more explicitly semantic implementation appears in SeaNet, an autonomic SDN management system driven by the ToCo ontology. SeaNet contains a knowledge graph generator, a SPARQL engine, and a network management API; formalizes expert experience and network management rules into a knowledge graph; and exposes technology-independent interfaces for users while packaging technology-specific details internally (Zhou et al., 2021). The reported evaluation compares SeaNet against the commercial SDN controller Ryu implemented in Python and states that SeaNet is considerably faster in most circumstances, that the SeaNet code is significantly more compact, and that RDF reasoning enables $O(1)$ time complexity on different scales of the knowledge graph, whereas the traditional database can achieve $O(n\log n)$ at its best (Zhou et al., 2021).

The DKG-based SDN architecture for intelligent swarm networks adopts a similar semantic stack but emphasizes continuous updating and operational integration. ONOS interfaces with P4 switches mainly via P4Runtime and gRPC; an RDFizer transforms collected metadata into RDF triples such as $\text{<Switch1, hasHopLatency, 10\ \mu s>}$; the graph database stores a constantly updated DKG; and a SPARQL engine provides a semantic query interface for dynamic topology, statistics, and intent or policy retrieval (Guo et al., 2024). Because the DKG captures topology, flow rules, hosts, switches, link status, and telemetry in a unifying ontology, it supports both local and federated reasoning across distributed controllers (Guo et al., 2024).

Knowledge graphs also appear in knowledge-based intent modeling for next-generation cellular networks. There, knowledge graphs are used to construct contexts and organize known information, while the proposed methodology extends the TM Forum intent common model so that high-level declarative intents can be formalized, reasoned over, and translated into service and resource models (Mehmood et al., 2023). This suggests a growing convergence between KDN and intent-based networking, with semantic reasoning serving as the bridge from declarative objectives to network control.

4. Learning and optimization methods

The foundational KDN literature treats ML method selection as application-dependent. Supervised learning is associated with automation, optimization, validation, estimation, and what-if analysis; unsupervised learning with improvement and recommendation; and reinforcement learning with automation and optimization in closed-loop operation (Mestres et al., 2016). In the original use cases, this included black-box modeling of an overlay network with hidden underlay and prediction of VNF resource usage. For overlay routing, a network of 12 overlay nodes and 19 underlay elements was simulated, and with 3,000 training samples the average delay model achieved less than $1\%$ relative error (Mestres et al., 2016).

Reinforcement learning quickly became a central KDN mechanism for routing. In one SDN routing study, the agent is built on an off-policy, actor-critic, deterministic policy gradient algorithm with two deep neural networks, where the state is the traffic matrix, the action is a tuple of link weights, and the reward is the negative mean end-to-end delay,

$r = - \overline{D}.$

The experiments use a scale-free network with 14 nodes and 21 full-duplex links, 10 traffic intensity levels, and 1,000 unique test traffic matrices; after training, the agent’s recommended routings achieve mean delays well within the first quartile of the benchmark distribution built from 100,000 randomly generated valid routing configurations (Stampa et al., 2017).

KDN-based cognitive routing has also been formulated as customizable metric computation and path-finding. In iRaaS, routing logic is represented as

$(f_{metric}(A,W), f_{sp}(G(V,E))),$

where the metric function can incorporate both traditional attributes and heuristic parameters from trained models, and the path-finding algorithm can be SPF, DUAL, or bespoke logic (Ghosh et al., 2024). Reliability is incorporated as a heuristic through the Sharpe Ratio,

$\textrm{Sharpe Ratio} = \frac{E[R]}{\sigma[R]},$

allowing route selection to prioritize stable and reliable paths rather than only shortest or least-loaded ones (Ghosh et al., 2024).

In industrial IT/OT autonomy, optimization is made explicit through a modular KDN framework composed of a Telemetry Collector, Knowledge Builder, Decision Engine, and Control Enforcer. The system constructs a knowledge graph $$\mathcal{G}_t = (\mathcal{V}, \mathcal{E}, \mathbf{X})$$ from telemetry and then selects actions through utility-guided optimization,

$$\mathcal{A}^* = \underset{\mathcal{A}' \subseteq \mathcal{A}}{\arg\max} \left[ \sum_{a_j \in \mathcal{A}'} U(a_j, \mathcal{G}_t) - \beta \cdot C(a_j, \mathcal{G}_t) \right],$$

with a Control Enforcer that maps chosen actions into concrete command sequences through SDN controllers or industrial protocol interfaces such as OPC-UA and Modbus (Bilen et al., 27 Sep 2025).

5. Representative systems, domains, and empirical evidence

KDN has been instantiated across markedly different environments. In smart-city mobility management, Seer demonstrates a scalable and fault-tolerant platform in which ONOS, Kafka, Spark, and Cassandra implement the full cycle from event extraction to knowledge dissemination and controller action (Sideris et al., 2016). In data-center management, an ML-based knowledge plane for leaf-and-spine topologies uses Mininet, Open vSwitch, POX, Kafka, and an LSTM neural network to forecast latency, fabric-link speed, and edge-link speed, then add or remove network nodes through OpenFlow-based southbound APIs in order to provide elastic capacity based on load forecasts (Sultan et al., 2020).

Swarm networking provides a concrete example of knowledge-graph-driven control. The DKG-based SDN paper presents use cases for access control in DDS/RTPS swarm communication, adaptive routing using INT-derived per-hop latency and P4Runtime rule updates, and resource-aware management by encoding node capability metadata as RDF and querying for conditions such as CPU load below a threshold (Guo et al., 2024). The same work argues that this normalized and queryable view supports effective allocation of resources and decision making at the application layer (Guo et al., 2024).

Industrial control is another major KDN application domain. In the modular IT/OT framework, evaluation uses a simulated 50-node hybrid IT/OT network with fluctuating load, link degradations, and component failures, and measures decision latency, control effectiveness, and system stability against Threshold-Based Event Triggering, Heuristic Rule Scheduler, and a Reinforcement Learning-based Controller. The reported results state that the KDN framework achieves the fastest and sharpest reduction in delays, superior stabilization of throughput, the lowest delay jitter and throughput variance, and significantly lower latency between issue detection and action than all baselines (Bilen et al., 27 Sep 2025).

In 6G management, KDN is increasingly coupled with predictive and semantic mechanisms. A twin-assisted architecture integrates Digital Twin models, graph-based knowledge abstraction, GNN reasoning, and zero-shot learning, and reports notable improvements in policy response time, SLA compliance rate, and intent matching accuracy while maintaining low computational and communication overhead (Bilen et al., 27 Sep 2025). A reinforcement-learning example for 6G resource management uses Q-learning to optimize UE-to-base-station association and base-station transmit power in ns-3 with OpenAI Gym via ns3-gym and the TeraSim extension, reporting higher aggregate throughput, lower latency, and reduced packet loss than a non-RL baseline in ultra-dense environments with dynamic user movement and traffic (Koçoğlu et al., 30 Sep 2025).

A more recent 6G line introduces semantic-aware network management through KDN. The proposed framework combines a semantic-reasoning module, a semantic-aware routing mechanism, and a semantic-distortion controller. In ns-3 evaluation, semantic delivery success improves by $12\%$, semantic distortion decreases by $O(n\log n)$0, re-routing events drop by $O(n\log n)$1, and throughput efficiency rises by $O(n\log n)$2 compared to shortest-path, load-based, and distortion-only routing baselines (Bilen et al., 13 Mar 2026). These results shift KDN from telemetry-driven optimization of conventional KPIs toward management of semantic relevance and semantic fidelity.

6. Limitations, misconceptions, and future directions

A persistent misconception is that KDN is simply SDN with an attached ML model. The literature instead defines a broader architectural stack in which telemetry, analytics, representation, reasoning, and control are explicitly connected through a knowledge plane (Mestres et al., 2016). At the same time, the literature does not converge on a single implementation strategy: some systems center on big-data pipelines, some on ontologies and SPARQL, some on dynamic knowledge graphs, some on digital twins, and some on reinforcement learning or zero-shot matching. A plausible implication is that KDN is best understood as an architectural pattern rather than a single algorithmic recipe.

The foundational challenges also remain. The original KDN paper calls for new ML algorithms suited to graph-structured, dynamic, and complex network data; notes that ML models may lack theoretical guarantees and interpretability; highlights the need for representative training sets; and identifies a shift in required skill sets toward combined networking and ML expertise, together with a need for public, standardized datasets (Mestres et al., 2016). Cross-domain knowledge-centric work adds synchronization of knowledge, privacy, policy, trust management, communication overhead, heterogeneity, business and regulatory constraints, and stability under continuous adaptation as major obstacles to practical adoption (Charalambides et al., 2020).

The same issues reappear in 6G-specific KDN research. Reinforcement-learning-based resource management identifies slow convergence for naive tabular methods in large state and action spaces, stability and interpretability issues for neural-network-based approaches, architectural complexity from integrating real-time SDN control and telemetry gathering with RL, and explainability, trust, accountability, and generalization as unresolved deployment concerns (Koçoğlu et al., 30 Sep 2025).

Recent work on agentic networking attempts to address another limitation: fragmented and redundant knowledge retrieval pipelines. KP-A proposes a unified Network Knowledge Plane that decouples knowledge acquisition and management from intelligence logic, exposes intuitive and consistent REST-like interfaces, maintains a lightweight knowledge graph, and demonstrates live network knowledge question answering and edge AI service orchestration with open-sourced implementation artifacts (Tang et al., 10 Jul 2025). This suggests that a major future direction for KDN is not only better optimization, but also standardization of knowledge interfaces so that multiple intelligence agents can operate over a common, semantically enriched, and reusable network knowledge substrate.