NDT Factory: Synthesizing Verified Network Digital Twins from Semantic Models via Multi-Agent LLM Sudipta Acharya1 , Petar Djukic2 , Burak Kantarci1 1 University of Ottawa, Ottawa, ON, Canada 2 Bell Labs Research, 600 March Road, Kanata, ON K2K 2E6, Canada
arXiv:2609.12170v1 [cs.NI] 10 Sep 2026
1 {sacharya2, burak.kantarci}@uottawa.ca, 2 [email protected]
Abstract—Autonomous network management requires systems that can evaluate Network Service Intents (NSIs) under varying conditions without manual implementation of analysis logic, as envisioned in TM Forum Level 4 (L4) autonomy. Behavioral Network Digital Twins (NDTs) enable such evaluation, but existing NDTs rely on pre-defined analytical logic, limiting adaptability for evolving closed-loop control. This paper introduces the NDT factory, a multi-agent software system that synthesizes executable behavioral NDTs on demand from semantic models using Large Language Model (LLM). We validate the system using a Call Admission Control (CAC) case study, where deterministic whatif analysis serves as the admission decision process. The NDT factory generates a complete CAC NDT through parallel synthesis and orchestration, achieving 100% compilation and test pass rates across multiple runs. Simulation over 300 NSIs shows 99.3% decision agreement with a reference implementation, 90% admission rate, and correct attribution of all rejections, demonstrating reliable synthesis with deterministic, verifiable execution. Index Terms—Network Digital Twin, Semantic Model, Large Language Models, Intent-Based Networking, Autonomous Networks.
I. I NTRODUCTION Network Service Intents (NSIs) are declarative, operatorissued specifications that express high-level service requirements without prescribing implementation details. Autonomous network management, as envisioned by TM Forum Level 4 (L4) autonomy [1], the Experiential Networked Intelligence (ENI) framework of the European Telecommunications Standards Institute (ETSI) [2], and Djukic et al. [3], requires networks to process NSIs and make admission decisions autonomously, while operators retain a supervisory monitoring role. A key challenge is determining how service request admission will affect network state and whether it may violate latency, utilization, or existing-service constraints. This work focuses on behavioral Network Digital Twins (NDTs), which prospectively apply a service request to a virtual state, recompute affected metrics, and verify request and existing-service constraints before modifying the live network. However, existing behavioral NDTs rely on predefined analytical logic fixed at design time as hand-coded algorithms or trained models [4]–[6]. This logic depends on the constraint semantics of an NSI. For example, bandwidth and latency requirements demand residual-capacity and path-delay analysis, whereas availability requirements may require redundant or
disjoint-path evaluation. Requests sharing the same constraintevaluation logic can reuse an NDT, but new constraint types, dependencies, or decision policies may require new evaluation modules. Consequently, evolving NSIs require repeated manual engineering, tightly coupling an intent’s declared outcome with the logic used to evaluate it. This limits scalable closedloop L4 autonomy [3] and motivates the automatic synthesis of behavioral NDTs from declarative specifications. In this paper, we propose the NDT factory, a multi-agent software system that synthesizes executable behavioral NDTs on demand. When a required NDT is absent, it generates behavioral evaluation logic through Large Language Model (LLM)-based code synthesis, validates it using a compile– test–debug loop, and caches the deterministic executable for reuse. Its central abstraction is the semantic model, a structured YAML specification of the inputs, operations, constraints, and validation cases of the target behavior without prescribing its source-code implementation. At runtime, the cached NDT evaluates incoming NSIs against the current network state without LLM involvement. We validate the system using a Call Admission Control (CAC) case study, where a complete multicomponent CAC NDT is synthesized from semantic models. The key contributions are: 1) Semantic model: A formal interface between intended NDT behavior and automatically generated managementplane executable logic. 2) NDT Factory: A multi-agent system that translates semantic models into deterministic, compile-and-test-validated executables through coordinated LLM-based synthesis. 3) End-to-end synthesis of the CAC NDT from semantic models, implementing deterministic what-if analysis, validated through discrete-event simulation on a realistic topology. The remainder is organized as follows: Section II reviews related work; Section III presents the NDT factory architecture and introduces the semantic model; Sections IV–V cover the case study and evaluation; Section VI concludes. II. R ELATED W ORK AND M OTIVATION Recent surveys establish NDTs as core infrastructure for network planning and control in 5G/6G systems [4], [7]. Existing NDT studies focus on architecture, analytics, or scenario-specific simulation rather than automatic behavioral
Fig. 1. Architecture of the NDT factory: in execution mode, a cached NDT produces decisions; in generation mode, the Planner coordinates parallel Coding agents to synthesize sub-components from semantic models, assemble the pipeline, and cache it for reuse
synthesis. Ak et al. develop what-if frameworks using datadriven evaluation [8] that rely on manually designed logic tied to specific scenarios. Recent 6G NDT architectures similarly assume behavioral modules are engineered separately [7]. Generative Artificial Intelligence (AI) approaches enhance data-driven analysis and decision support within NDTs [5], [9] while on-demand synthesis of executable logic for unseen intent types remains an open research opportunity. Recent work by Djukic et al. [3] positions the digital twin factory as a management-plane agent that uses Large AI Models to interpret semantic models and synthesize NDTs in response to evolving network conditions. Building on this standardsoriented vision, we implement and evaluate an executable multi-agent pipeline for behavioral NDT synthesis. Another research thread focuses on LLM-based code generation, which offers synthesis capabilities through multi-turn and collaborative frameworks [10]–[12], with domain-specific extensions to networking [13]. While prior approaches treat code generation as a prompt-driven software development task, our objective is the synthesis of executable behavioral NDTs from semantic models that formally define domain inputs, operations, constraints, output conventions, and validation tests. In our system, the LLM is restricted to synthesis, while the compiled NDT executable performs runtime behavioral analysis. Prior NDT research focuses on architectures and scenario-specific what-if analysis, while LLMs enable general synthesis. In contrast, our approach grounds synthesis in explicit behavioral semantics and makes the semantic model the primary driver, ensuring correctness through test-based validation. III. T HE PROPOSED SYSTEM : NDT FACTORY The NDT factory is a multi-agent software system composed of four interacting components: the Intent handler agent, NDT factory agent, Planner agent, and a pool of parallel Coding agents. The proposed system operates in two modes.
In generation mode, triggered when a required NDT is absent from the cache, the Planner and Coding agents collaboratively synthesize, compile, and validate components from semantic models to construct the target NDT. In execution mode, for subsequent NSIs requiring the same analysis, the pregenerated NDT is invoked by the NDT factory agent, eliminating generation overhead. Once created, the NDT executes deterministically while preserving semantic constraints. Fig. 1 illustrates the overall architecture and workflow of the NDT factory. a) Intent handler agent: The Intent handler is the entry point for incoming NSIs. It performs two functions. First, it parses and validates the NSI by enforcing syntactic constraints, including type, range, and consistency checks, rejecting malformed or incomplete requests. While this validation ensures that the intent is well-formed, it does not fully capture its semantic correctness or operational feasibility. Second, it transforms the validated intent into a structured behavioral analysis query (e.g., a what-if evaluation query). This query is forwarded to the NDT factory agent. b) NDT factory agent: The NDT factory agent acts as the central coordinator of the software system. It receives the structured query from the Intent handler and manages execution of the behavioral NDT. Its responsibilities include: 1) NDT lookup: Check whether the required NDT binary is available in the cache. 2) On-demand generation: If unavailable, invoke the Planner agent to synthesize, compile, and validate the NDT from the corresponding semantic model, and cache the resulting binary. 3) Metadata collection: Retrieve runtime network and service state, including topology (link capacities and utilization) and active services (paths, bandwidth allocations, and Service Level Agreement (SLA) constraints). 4) NDT execution: Construct the NDT input by combining
the query with collected metadata, invoke the binary, and parse its structured output. To ensure consistency, it resolves the NDT input schema by aligning semantic model data structures with the generated code interfaces; this mapping is cached after the first invocation. 5) State update and release: Update the network state upon admission, and release allocated resources when services complete or expire. c) Planner agent: Given a high-level orchestrator semantic model specifying the behavioral twin’s components and dependencies, the Planner produces a compiled and verified executable NDT. Unlike conventional planners that decompose NSIs into data-plane network services, it operates in the management plane to synthesize an NDT service for behavioral intent evaluation. The system therefore distinguishes the data-plane network service from the management-plane NDT service. The Planner operates as follows: Phase 0: Parsing Extract component (semantic models) dependencies from the orchestrator semantic model. Phase 1: Parallel generation Retrieve the component semantic models, resolve dependencies, and distribute independent components among Coding agents for concurrent source-code generation and compilation. Phase 2: Context assembly Build an orchestration context containing the generated components’ binary interfaces, data-flow contracts, and pipeline order to support correct integration. Phase 3: Orchestrator generation Generate the orchestrator source code via the Coding agent using the orchestrator semantic model and assembled context. The orchestrator acts as the main function of the NDT, coordinating all dependent components and producing the final decision. Phase 4: Assembly and verification Assemble the components into a complete pipeline and verify its correctness and completeness, yielding the executable behavioral NDT. d) Coding agent: The Coding agent is the generative unit of the system. It performs the following tasks: 1) Construct a structured prompt from the semantic model and optional context. 2) Invoke the LLM, which generates source code and executes tool calls (file writes, compilation, and test execution) within its agentic context. The LLM operates on both the prompt and tool-call outputs. 3) Validate that the generated code compiles and passes all semantic-model-defined test cases. 4) On failure, incorporate compiler and test output as feedback into a new prompt and retry (up to four iterations). A synthesized code component is accepted only if it compiles successfully and passes all specified tests. End-to-End Flow: The end-to-end workflow of the NDT factory is described below. Step 1. Intent parsing: The Intent handler receives an NSI, validates parameters, and transforms it into a structured behavioral query forwarded to the NDT factory.
Semantic Model: Bandwidth Feasibility Pruner name: bandwidth_feasibility_pruner description: Prune paths where bandwidth demand exceeds available link capacity parameters: - name: topology type: NetworkTopology - name: request type: ServiceRequest fields: [src_node, dst_node, bandwidth_mbps] operations: - name: PrunePaths description: Return paths with sufficient residual bandwidth on all links conventions: exact_json_fields: [feasible_paths, pruned_count] tests: - input: {bandwidth_mbps: 100} expected: {feasible_paths: [...]}
Fig. 2. Semantic model of the Bandwidth Feasibility Pruner (CAC case study)
Step 2. NDT lookup: The NDT factory agent checks whether a compiled NDT for the required intent type exists in the cache. Step 3. Execution mode: If found, the NDT factory agent collects the current network and service states, invokes the cached NDT, and returns the admission decision without LLM involvement. Step 4. Generation mode – Sub-component synthesis: Otherwise, the NDT factory agent invokes the Planner, which retrieves the orchestrator semantic model, extracts dependencies, and dispatches Coding agents in parallel to synthesize and validate sub-components via an LLM-driven compile–test–debug loop. Step 5. Generation mode – Context assembly: The Planner constructs the orchestration context from generated sub-components and forwards it, along with the orchestrator semantic model, to a Coding agent. Step 6. Generation mode – Orchestrator synthesis: The Coding agent synthesizes the orchestrator source code using the provided context and semantic model. Step 7. Pipeline assembly and caching: The Planner assembles and validates the sub-components and orchestrator, then returns the compiled NDT to the NDT factory agent, which caches the binary and proceeds as in Step 3. The Semantic Model: The semantic model is a structured, verifiable YAML specification defining an NDT’s intended behavior through its inputs, data structures, operations, constraints, output conventions, and test cases. It follows the parameter and data-structure conventions of the Internet Engineering Task Force (IETF) NDT architecture [14] and the 3𝑟 𝑑 Generation Partnership Project (3GPP) TR 28.915 [6], facilitating integration with existing network models. For each target NDT, network-domain specialists define its logic, constraints, and outputs, while system engineers encode them as structured specifications and validation cases. Operationally, these models should undergo structural checks, expert review, and reference-case validation under version control, with each approved change triggering revalidation, cache invalidation,
NSI 𝑟 = (𝑠, 𝑡, 𝐵, 𝐿 max , 𝑇) + Network State (𝐺, S)
and NDT regeneration. Fig. 2 presents an example of semantic model from the case study (Section IV). IV. C ASE S TUDY We validate the system through a CAC case study in packetswitched networks. Given an incoming NSI, the CAC NDT applies a deterministic what-if algorithm that projects the postadmission network state and evaluates bandwidth availability, link utilization, end-to-end latency, and existing-service SLAs. It admits the request only if all constraints hold; otherwise, it rejects it with per-constraint reasoning.
Bandwidth Feasibility Pruner (C1)
K-Shortest Candidate Paths Path Latency Constraint Check (C3)
Link Util. Constraint Check (C2)
∀ 𝑒 ∈ 𝑃 : (1 − 𝜌𝑒 ) 𝐶𝑒 ≥ 𝐵 ∀ 𝑒 ∈ 𝑃 : 𝜌𝑒 + 𝐵/𝐶𝑒 ≤ 𝑈max Í 𝐿 (𝑃) = 𝑒∈ 𝑃 ℓ𝑒 ≤ 𝐿 max ∀ 𝑘 ∈ S s.t. 𝑃 𝑘 ∩ 𝑃 ≠ ∅ : 𝐿 ′ (𝑃 𝑘 ) ≤ 𝐿 max 𝑘
(C1) (C2) (C3) (C4)
where ℓ𝑒 = 𝑑 𝑒 + 𝜌𝑒new /[𝜇𝑒 (1 − 𝜌𝑒new )] is the sum of propagation delay and M/M/1 mean queueing delay, and 𝐿 ′ (𝑃 𝑘 ) is the projected latency of service 𝑘 after admission, and 𝜌max (𝑃) = max𝑒∈ 𝑃 (𝜌𝑒 + 𝐵/𝐶𝑒 ) is the maximum postadmission link utilization along 𝑃. The decision is to select 𝑃∗ = arg min 𝑃 ∈ F (𝑟 ) 𝜎(𝑃), where F (𝑟) ⊆ P (𝑠, 𝑡) is the ( 𝑃) 𝑃) + (1−𝛼) 𝜌max feasible set and 𝜎(𝑃) = 𝛼 𝐿𝐿(max 𝑈max , 𝛼 ∈ [0, 1] is a composite cost over normalized latency and utilization (lower is preferable), or reject with path-level reasoning if F (𝑟) = ∅.
Affected Serv. SLA Check (C4)
Path Scoring & Ranking 𝜎(𝑃): latency, postadmission utilization
A. Problem Formulation Let 𝐺 = (𝑉, 𝐸) be a bidirected network graph, where each link 𝑒 ∈ 𝐸 has capacity 𝐶𝑒 (Mbps), propagation delay 𝑑 𝑒 (ms), and utilization 𝜌𝑒 ∈ [0, 1). The active service set S = {(𝑃 𝑘 , 𝐵 𝑘 , 𝐿 max 𝑘 )} records the path, reserved bandwidth, and latency SLA of each admitted service. Let 𝑠¯ = 1 kbit denote the mean packet size. Since 1 Mbps equals 1 kbit/ms, the M/M/1 service rate of link 𝑒 is 𝜇𝑒 = 𝐶𝑒 /𝑠¯ packets/ms. An NSI 𝑟 = (𝑠, 𝑡, 𝐵, 𝐿 max , 𝑇) specifies source/destination, required bandwidth, latency bound, and duration. 𝑈max ∈ (0, 1) is a network-wide link utilization threshold set by the operator. Suppose, on the National Science Foundation Network (NSFNet) backbone [15], an NSI requests a 100 Mbps flow from Salt Lake City to Atlanta with latency ≤ 52ms and duration 30s, encoded as 𝑟 = (Salt Lake City, Atlanta, 100 Mbps, 52 ms, 30 s). Let P (𝑠, 𝑡) denote the set of 𝐾 candidate paths between 𝑠 and 𝑡. A path 𝑃 ∈ P (𝑠, 𝑡) is feasible iff:
(1 − 𝜌𝑒 )𝐶𝑒 < 𝐵 ⇒ prune
Pruned Network Topology identify
Admission Decision: A DMIT (𝑃∗ ) / R EJECT
Fig. 3. CAC pipeline with underlying what-if analysis logic. Six components (as shown in Table I) implement Algorithm 1, with constraint checks (C1–C4)
and self-contained binaries, although the system is languageagnostic. Algorithm 1 Deterministic what-if analysis for CAC Require: Network state (𝐺, S) ; NSI 𝑟 = (𝑠, 𝑡 , 𝐵, 𝐿max , 𝑇 ) ; utilization threshold 𝑈max ; number of candidate paths 𝐾 Ensure: A DMIT ( 𝑃 ∗ ) or R EJECT with per-path reasons 1: Stage 1 – Topology Pruning (C1): 𝐺 ′ ← {𝑒 ∈ 𝐺 : (1 − 𝜌𝑒 )𝐶𝑒 ≥ 𝐵} 2: Stage 2 – Path Enumeration: P (𝑠, 𝑡 ) ← Yen(𝐺 ′ , 𝑠, 𝑡 , 𝐾 ) ; F (𝑟 ) ← ∅ 3: Stage 3 – Constraint Filtering (C2–C4): 4: for all 𝑃 ∈ P (𝑠, 𝑡 ) do 5: if ∃ 𝑒 ∈ 𝑃 : 𝜌𝑒 + 𝐶𝐵𝑒 > 𝑈max then 6: Record reason: utilization violation (C2); continue 7: end if new 8: 𝜌𝑒 ← 𝜌𝑒 + 𝐶𝐵𝑒 , ∀𝑒 ∈ 𝑃 𝜌new
new < 1, else +∞ 𝑒 9: ℓ𝑒 ← 𝑑𝑒 + 𝜇 (1−𝜌 new , for 𝜌𝑒 𝑒 ) Í𝑒 10: 𝐿 ( 𝑃) ← 𝑒∈ 𝑃 ℓ𝑒 11: if 𝐿 ( 𝑃) > 𝐿max then 12: Record reason: latency violation (C3); continue 13: end if 14: ok ← true 15: for all 𝑘 ∈ S such that 𝑃𝑘 ∩ 𝑃 ≠ ∅ do proj 16: Compute projected utilization 𝜌𝑒 and 𝐿 ′ ( 𝑃𝑘 ) 17: if 𝐿 ′ ( 𝑃𝑘 ) > 𝐿 𝑘max then 18: Record reason: SLA violation (C4); ok ← false; break 19: end if 20: end for 21: if ok then 22: F (𝑟 ) ← F (𝑟 ) ∪ { 𝑃} 23: end if 24: end for 25: if F (𝑟 ) = ∅ then 26: return R EJECT(reasons) 27: end if 28: Stage 4 – Path Scoring: 𝑃 ∗ ← arg min 𝑃 ∈F (𝑟 ) 𝜎 ( 𝑃) 29: Stage 5 – State Update: 30: for all 𝑒 ∈ 𝑃 ∗ do 31: 𝜌𝑒 ← 𝜌𝑒 + 𝐶𝐵𝑒 32: end for 33: Register 𝑟 in S ; return A DMIT ( 𝑃 ∗ )
B. Underlying Deterministic what-if Analysis for CAC Fig. 3 illustrates the flow, and Algorithm 1 defines the deterministic what-if analysis for CAC, comprising topology pruning (C1), path enumeration, constraint filtering (C2–C4), path selection, and state update. The formulation uses a rate-based utilization model and an M/M/1 queueing-delay model, where post-admission utilization and per-link delay are computed in Stages 1–3 of Algorithm 1 for constraints C1–C4. We have decomposed this logic into seven semantic models: six sub-components and one orchestrator (Table I). In this case study, Go is used for its fast compilation, static typing,
V. E XPERIMENTAL E VALUATION Although architecturally LLM-backend-agnostic, the proposed system uses Claude Sonnet 4.6 [16] as the Codingagent backend for the primary experiments and evaluates Qwen3-Coder-30B-A3B-Instruct in Section V-A3 to assess open-source-backend sensitivity. A. Sub-component Evaluation 1) Metrics: Each generated Go program is evaluated using four metrics: compilation success 𝐶 ∈ {0, 1}, test pass rate
TABLE I CAC NDT: S EMANTIC M ODELS , G ENERATED C ODE S IZE , A LGORITHMIC C OMPLEXITY, AND S YNTHESIS C OST ( TOKENS , LATENCY: MEAN ± STD , 10 RUNS ). 𝑁 =|𝑉 |: NODES , 𝑀=| 𝐸 |: LINKS , 𝐾 : CANDIDATE PATHS , | 𝑃 |: PATH LENGTH , | S |: ACTIVE SERVICES , LOC: L INES O F C ODE Semantic Model
LOC Role in Algorithm 1
Complexity
Bandwidth Feasibility Pruner Graph Path Finder Link Utilization Constraint Checker Path Latency Constraint Checker Affected Services SLA Checker Dynamic Service Catalog
137
O(𝑀)
Orchestrator
Tokens
Lat. (s)
3059±79
54.3±8.8
TABLE III B EHAVIORAL C OMPARISON : S YNTHESIZED VS . R EFERENCE CAC NDT S Metric
Synth. NDT
Ref. NDT
Total requests Admitted Rejected Blocking probability
300 271 (90.3%) 29 (9.7%) 0.097
300 273 (91.0%) 27 (9.0%) 0.090
37,168.2 33,546.2 90.3%
37,168.2 33,806.2 91.0%
30.6 67.7 37.0
30.0 67.5 37.4
C3 only 99.3%
C3 only –
169
C1: prune links, (1 − 𝜌𝑒 )𝐶𝑒 < 𝐵 𝐾 -shortest path algorithm (Yen’s) C2: 𝜌𝑒new > 𝑈max
O (𝐾 𝑁 ( 𝑀 𝑁 log 𝑁 ) ) O(|𝑃|)
175
C3: 𝐿 ( 𝑃) > 𝐿max
O(|𝑃|)
3667±148 52.2±21.3
Avg. path latency of admitted NSIs (ms) Avg. 𝐿max of admitted NSIs (ms) Avg. latency margin of admitted NSIs (ms)
450
C4: 𝐿 ′ ( 𝑃𝑘 ) > 𝐿 𝑘max
O(|S| · |𝑃|)
4071±113 75.4±17.1
Rejection cause Decision agreement
465
Path scoring 𝜎 ( 𝑃) ; state update
O (𝐾 · | 𝑃 | )
4517±675 107.7±47.7
542
Coordinates pipeline; final decision
O (𝐾 𝑁 ( 𝑀 𝑁 log 𝑁 ) 𝐾 |S||𝑃|)
+ 8813±173 189.8±35.2 +
440
+ 4758±145 138.6±39.0 3517±383 64.0±18.3
TABLE II M ULTI - RUN C ODE G ENERATION Q UALITY ( MEAN ± STD , 10 RUNS ) Component
LOC Attempts Comp. Test
Bandwidth Pruner Path Finder Util. Checker Latency Checker SLA Checker Service Catalog
137 440 169 175 450 465
2.1 ± 0.3 2.3 ± 0.4 2.0 ± 0.0 2.0 ± 0.0 2.1 ± 0.3 2.1 ± 0.3
1 1 1 1 1 1
1.00 1.00 1.00 1.00 1.00 1.00
Qual.
Sem. Sim.
Overall
Average
306
2.1 ± 0.2
1
1.00 9.9 ± 0.1 0.76 ± 0.01 0.987 ± 0.002
9.9 ± 0.1 0.76 ± 0.02 0.987 ± 0.002 9.5 ± 0.2 0.77 ± 0.02 0.981 ± 0.003 10.0 ± 0.0 0.76 ± 0.01 0.988 ± 0.001 10.0 ± 0.0 0.76 ± 0.01 0.988 ± 0.001 10.0 ± 0.0 0.76 ± 0.01 0.988 ± 0.001 10.0 ± 0.0 0.76 ± 0.01 0.988 ± 0.001
T ∈ [0, 1], code quality 𝑄 ∈ [0, 10], and semantic similarity 𝜉 ∈ [0, 1]. The overall correctness score is defined as 𝑄 𝑆 = 𝑤 1 𝐶 + 𝑤 2 T + 𝑤 3 10 + 𝑤 4 𝜉, where 𝑤 1 , 𝑤 2 , 𝑤 3 , 𝑤 4 denote Í the relative importance of each metric with 𝑖 𝑤 𝑖 = 1. In our implementation, 𝑤 1 = 0.30, 𝑤 2 = 0.50, 𝑤 3 = 0.15, and 𝑤 4 = 0.05, prioritizing functional correctness over structural quality and semantic alignment. Code quality 𝑄 is computed via Go Abstract Syntax Tree (AST) analysis with base 5.0 and increments for error handling (+2.0), function decomposition (+1.5), custom types (+1.0), and comments (+0.5). Semantic similarity 𝜉 is computed as a weighted comparison of JSON fields (30%), data structures (20%), operations (20%), argument style (15%), and computation logic (15%). 2) Results: Table II shows that all six sub-components compile and pass every semantic-model-defined test across 10 runs, establishing test-defined correctness. Attempts vary slightly due to differences in LLM convergence, while compilation and test outcomes remain invariant. Code quality and semantic similarity also remain stable, with the latter varying by only ±0.01–0.02, indicating consistent structure and semantic alignment. Similar scores are expected because several components derive structurally similar logic from uniform templates, with complexities from 𝑂 (|𝑃|) to 𝑂 (|S| · |𝑃|) (Table I). The path-finding component exhibits slightly greater variance because Yen’s 𝐾-shortest-path algorithm, with complexity 𝑂 (𝐾 𝑁 (𝑀 + 𝑁 log 𝑁)), is structurally more demanding to synthesize. Overall, the results show that the compile–test–debug loop
Bandwidth requested (Mbps) Bandwidth admitted (Mbps) Bandwidth efficiency
produces reliable and repeatable implementations with Claude Sonnet 4.6. Table I also reports mean token usage and wallclock latency over the same 10 runs. From the Bandwidth Pruner (𝑂 (𝑀)) to the Orchestrator (𝑂 (𝐾 𝑁 (𝑀 + 𝑁 log 𝑁) + 𝐾 |S||𝑃|)), token usage increases from 3,059 to 8,813 (2.9×), while latency increases from 54.3 to 189.8 s (3.5×). Thus, synthesis cost increases moderately across the evaluated complexity range. 3) LLM-backend sensitivity: We evaluated Qwen3-Coder30B-A3B-Instruct [17] on the six sub-component semantic models over 10 runs each. Claude Sonnet 4.6 succeeded in 60/60 runs, while Qwen produced compiling, test-passing implementations in 41/60 (68.3%Catalogue): 10/10 for Dynamic Service Catalog, 9/10 each for Bandwidth Pruner, Path Latency Checker, and SLA Checker, 4/10 for Link Utilization Checker, and 0/10 for Graph Path Finder. The latter consistently generated only one of the two required distinct shortest paths, preventing orchestrator and complete CAC NDT synthesis. Across these models, per-model mean latency ranged from 86–488 s for Qwen versus 52–139 s for Claude Sonnet 4.6 (Table I). Thus, the architecture supports different LLM backends, but synthesis reliability strongly depends on model capability. B. End-to-End CAC NDT Evaluation 1) Simulation scenario: A Python discrete-event simulator routes NSIs from arrival through the Intent handler and NDT factory to execution, scheduling arrivals and departures in a time-ordered priority queue. Correctness is evaluated against a handcrafted Python CAC NDT implementing Algorithm 1, with both NDTs receiving the same arrival sequence and identical initial network and service states. We simulate 300 NSIs over 490.5 s on the 14-node, 21-link NSFNet [15], with Poisson arrivals (mean inter-arrival 1.71 s), 𝐵 ∼ U [50, 200] Mbps, 33 s mean service duration, 𝐿 max ∼ U [30, 100] ms, 𝑈max = 80%, and 𝐾 = 3. The weight 𝛼 = 0.6 prioritizes latency as the service-critical dimension. 2) Results: Table III summarizes the results for 300 NSIs. The synthesized Go NDT agrees with the handcrafted Python reference on 298 admission decisions (99.3%), demonstrating close behavioral agreement. The two disagreements are latency-boundary cases: the path rejected in each case exceeds
Max Link Utilization (%)
Synthesized NDT
can be expressed as semantic models and integrated into the same pipeline. Ongoing work includes systematic evaluation of LLM backends, semantic model refinement through execution feedback, dynamic intent classification, packet-level simulation, and extension toward 5G Radio Access Network (RAN) scenarios.
Reference NDT
80
𝑈max = 80%
60 40 20 0
ACKNOWLEDGMENT 0
100
200 300 400 Simulation Time (s)
500
Fig. 4. Max link utilization (300 NSIs, 490.5 s) for both twins; peak 54.6% (synth.) / 56.9% (ref.), 𝑈max = 80%
the corresponding maximum permitted latency by less than 1%. Every admitted NSI satisfies constraints (C1)–(C4), while all rejections in both twins arise solely from C3. For state fidelity, comparing all 21 links after each of the 300 NSI decisions yields 6,300 utilization comparisons with a mean absolute error of 0.7 percentage points and a maximum of 24.4 points. This divergence arises mainly because numerical tiebreaking causes 22 of 271 jointly admitted requests to select different but equally admissible paths, leading subsequent loads to accumulate on different links. Fig. 4 shows maximum link utilization over the 490.5,s simulation, peaking at 54.6% for the synthesized NDT and 56.9% for the reference, both below 𝑈max = 80%. Thus, C1, C2, and C4 are never binding, and the rise-and-fall pattern confirms correct resource allocation and release. However, this moderate-load scenario does not exercise the C2 boundary, motivating future higher-load validation. Because both twins process each NSI at the same event without artificial delay, state staleness is not evaluated. Security considerations: The Coding agent prompts the LLM using semantic models and Planner-assembled context, allowing malicious or modified semantic models or compromised context to inject instructions and produce unsafe code. Compilation and predefined tests detect syntax and tested behavioral errors but cannot guarantee freedom from vulnerabilities or untested behavior. Thus, “verified” means passing compilation and specified tests, not formal verification or security certification. Deployment additionally requires authenticated semantic models, isolated generation and testing, restricted tool access, static analysis, resource limits, and prior approval. VI. C ONCLUSION In this paper, we presented the NDT factory, a multi-agent software system for on-demand synthesis of behavioral NDTs from semantic models. Validated on a CAC case study over NSFNet, the system generated a complete CAC NDT pipeline with 100% compilation and test success across multiple runs. Simulation of 300 NSIs yielded 99.3% decision agreement with a reference implementation and a 90% admission rate, confirming reliable synthesis and deterministic execution. Beyond CAC, the approach can extend to other behavioral network functions, such as quality of service (QoS) enforcement, fault localization, and traffic engineering, which
This work is supported in part by MITACS Accelerate Program project IT43178 and in part by the Natural Sciences and Engineering Research Council (NSERC) DISCOVERY and CREATE TRAVERSAL programs. R EFERENCES [1] TM Forum, “Autonomous Networks – Reference Architecture,” https://www.tmforum.org/resources/introductory-guide/ ig1251-autonomous-networks-reference-architecture-v1-0-1/, 2022, tM Forum, IG1251, Version 1.0.1. [2] ETSI, “Experiential Networked Intelligence (ENI); Study on AI Agents based Next-generation Network Slicing,” https://www.etsi.org/deliver/ etsi gr/ENI/001 099/051/04.01.01 60/gr ENI051v040101p.pdf, 2025, eTSI GR ENI 051 V4.1.1, February 2025. [3] P. Djukic, S. Acharya, T. E. Kennouche, and B. Kantarci, “From agentic to autogenic network management for ai-native 6g and beyond: A standards perspective,” IEEE Network, pp. 1–9, 2026. [4] R. Verdecchia, L. Scommegna, B. Picano, M. Becattini, and E. Vicario, “Network digital twins: A systematic review,” IEEE Access, vol. 12, pp. 145 400–145 416, 2024. [5] T. Li, Q. Long, H. Chai, S. Zhang, F. Jiang, H. Liu, W. Huang, D. Jin, and Y. Li, “Generative ai empowered network digital twins: Architecture, technologies, and applications,” ACM CSUR, vol. 57/6, pp. 1–43, 2025. [6] 3GPP, “Study on management aspect of Network Digital Twin,” https:// www.3gpp.org/DynaReport/28915.htm, 2024, 3GPP TR 28.915 V19.0.0, Release 19, December 2024. [7] Z. Yang, C. Papagianni, A. Belloum, and P. Grosso, “An architectural framework for 6g network digital twins system,” in Annual Intl Conf on Mobile Computing and Networking, 2024, pp. 2437–2441. [8] E. Ak, B. Canberk, V. Sharma, O. A. Dobre, and T. Q. Duong, “What-if analysis framework for digital twins in 6g wireless network management,” in IEEE WCNC, 2024, pp. 232–237. [9] K. Muhammad, T. David, G. Nassisid, and T. Farus, “Integrating generative ai with network digital twins for enhanced network operations,” arXiv preprint arXiv:2406.17112, 2024. [10] C. Qian, W. Liu, H. Liu, N. Chen, Y. Dang, J. Li, C. Yang, W. Chen, Y. Su, X. Cong et al., “Chatdev: Communicative agents for software development,” in Annual meeting of the association for computational linguistics (volume 1: Long papers), 2024, pp. 15 174–15 186. [11] S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, J. Wang, C. Zhang, Z. Wang, S. K. S. Yau, Z. Lin et al., “Metagpt: Meta programming for a multi-agent collaborative framework,” in The twelfth international conference on learning representations, 2023. [12] J. Jiang, F. Wang, J. Shen, S. Kim, and S. Kim, “A survey on large language models for code generation,” ACM Transactions on Software Engineering and Methodology, vol. 35, no. 2, pp. 1–72, 2026. [13] K. B. Kan, H. Mun, G. Cao, and Y. Lee, “Mobile-llama: Instruction fine-tuning open-source llm for network analysis in 5g networks,” IEEE Network, vol. 38, no. 5, pp. 76–83, 2024. [14] C. Zhou, H. Yang, X. Duan, D. Lopez, A. Pastor, Q. Wu, M. Boucadair, and C. Jacquenet, “Network digital twin: Concepts and reference architecture,” Internet Engineering Task Force, Internet-Draft draft-irtf-nmrgnetwork-digital-twin-arch-05, 2024. [15] R. Matzner, D. Semrau, R. Luo, G. Zervas, and P. Bayvel, “Making intelligent topology design choices: understanding structural and physical property performance implications in optical networks,” J. of Optical communications and Netw., vol. 13/8, pp. D53–D67, 2021. [16] Anthropic, “Claude 4.6 Sonnet,” https://www.anthropic.com, 2025, accessed: 2026-04. [17] A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv et al., “Qwen3 technical report,” arXiv preprint arXiv:2505.09388, 2025.