| Internet-Draft | Intent Translation and Validation | November 2026 |
| Gu, et al. | Expires 19 May 2027 | [Page] |
This document describes an agentic AI workflow for detecting and mitigating structural and semantic errors, including hallucinated policy content, when translating a natural-language network intent into structured policies. The workflow coordinates role-specialized language-model functions with deterministic validation tools within a predefined action space and a bounded retry budget. Schema-constrained generation limits structural defects, while cross-slot checks and intent-faithfulness assessment identify a potentially unsupported or inconsistent policy content. Structured validation traces guide targeted re-extraction and regeneration. Unresolved cases retain explicit failure status for downstream review. This document describes component interactions, validation outcomes, and recovery behavior, and also presents a 3GPP TS 28.312-based instantiation for mobile network management.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
The increasing scale and heterogeneity of networks and services make manual policy configuration and management increasingly difficult.¶
Intent-Based Management is a paradigm that allows an administrator to specify desired outcomes through high-level intents, often expressed in natural language [Survey-IBN-CST-2023], [USENIX-ATC-Lumi], [I-D.jeong-nmrg-ibn-network-management-automation]. These intents must then be interpreted, validated, and translated into structured policy representations that can be executed by network functions and orchestrators. Recent work has explored the use of large language models for this translation step [Mekrache-IBN]. Standards such as 3GPP TS 28.312 [TS-28.312] define lifecycle procedures, and an OpenAPI schema for managing intents in mobile networks (e.g., 5G networks) and TR 28.812 [TR-28.812] describe the scenarios that motivate them. However, they do not specify mechanisms for interpreting natural language or translating it into compliant policy structures.¶
A central difficulty observed in recent industry benchmarks [GSMA-TeleYAML] is the so-called structural-semantic gap. A policy document may be syntactically valid against the schema while still being semantically incoherent across slots (e.g., declaring an object type that is incompatible with the chosen target metric). Linguistic proficiency of a language model alone is insufficient to close this gap. Standards-grounded structural constraints and post-generation validation are also required.¶
This document defines an intent translator for not only translating a natural-language network intent into a structured policy but also detecting and mitigating structural and semantic errors. This intent translator is a core component in an Agentic AI Framework for managing networks, security, and AI services [I-D.jeong-nmrg-agentic-ai-framework]. The contributions in this document includes the explicit connection between constrained policy generation, complementary validation checks, and failure-directed recovery. The proposed framework retains the parallel extraction and translation pipeline and illustrates its use through the policy modeling and management service interfaces defined in 3GPP TS 28.312 [TS-28.312].¶
The framework is composed of four functional components that operate in a partially parallel pipeline, plus a deterministic merge step and a feedback router:¶
A trace-driven recovery agent consumes the validator's failure-mode trace and dispatches targeted regeneration to the appropriate upstream component, rather than performing a generic retry. The design promotes modularity, transparency, and alignment with existing network automation architectures, enabling consistent translation of an operator's goals into policies that are interoperable with standard orchestration and management systems in network environments.¶
The scope is natural-language intent interpretation, policy generation, and pre-deployment validation and recovery. Checks are limited to the original intent, the selected schema and relational rules, and authoritative context explicitly supplied to the workflow. Few-shot examples illustrate representations; they do not establish facts or requirements for the current request.¶
Autonomous control of operational networks, device-level policy enforcement, runtime intent assurance, and verification of network conditions not supplied to the workflow are outside this document's scope. The document does not specify independent agent runtimes, agent discovery or inter-agent communication protocols, or network digital twin integration. These capabilities are not prerequisites for the translation workflow.¶
Error-free translation, quantified hallucination reduction, superiority over non-agentic approaches, and generalization across domains or models are not established by the preliminary implementation description. These are unvalidated claims, distinct from the architectural scope exclusions above; relevant evaluation considerations are given in Section 9.1.¶
This document uses the terminology defined in [RFC9315], [RFC8329], [I-D.ietf-i2nsf-applicability], [I-D.jeong-nmrg-security-management-automation], and [SPT].¶
In addition, the following terms are defined for the purpose of this document:¶
This section defines the architecture of the Intent Translator Framework for natural-language intent translation, validation, and bounded recovery. The following role-and-scenario classifications, target schemas, and relational invariants describe a 3GPP TS 28.312-based instantiation [TS-28.312] for mobile network management. Applying the same pipeline to another domain requires corresponding domain-specific definitions; such applicability is not established by the current preliminary experiments.¶
The Intent Translator is a modular subsystem responsible for converting natural language intent into a structured, machine-readable policy document suitable for enforcement in intent-based management systems. It forms the core of the intent translation framework, providing parallel extraction, schema-constrained generation, multi-dimensional validation, and trace-based adaptive retry. The final output is expressed in a structured format such as YAML and adheres to the policy modeling defined in [TS-28.312].¶
Architecturally, the Intent Translator operates as a partially parallel pipeline composed of four functional components, a deterministic merge step (the Intent Composer), and a feedback router (the trace driven recovery agent). The two Extractors execute in parallel on the same input; their outputs are merged by the Intent Composer and consumed by the Policy Generator. The Policy Validator then evaluates the candidate policy along three complementary dimensions, and the trace driven recovery agent uses the resulting failure-mode trace to dispatch targeted regeneration when needed. The pipeline supports schema-grounded extraction, schema-as-grammar generation, failure-mode-specific validation, and adaptive retry. It is designed to support transparent, extensible, and standards-aligned translation of human goals into actionable configurations.¶
+----------+
| IBN User |
+----------+
|
| natural language intent
Intent Translator v
+--------------+------------------------+----------------------------+
| | natural language | natural language |
| v intent v intent |
|(feedback)+---------------------+ +---------------------+(feedback)|
+--------->| Scenario Extractor | | Slot Extractor |<---------+
| +---------------------+ +---------------------+ |
| | | |
| | (parallel inference) | |
| +-------------+--------------+ |
| | |
| v |
| +---------------------+ |
| | Intent Composer | |
| +---------------------+ |
| | |
| v |
| (feedback) +---------------------+ +----------------+ |
+------------------->| Policy Generator |<---| Policy | |
| +---------------------+ | Knowledeg Base | |
| | +----------------+ |
| v |
| +---------------------+ |
| | Policy Validator | |
| +---------------------+ |
| | |
| pass | fail (with trace) |
| +-----------+-----------+ |
| | v |
| | +-------------------+ |
| | | Trace driven | |
| | | recovery agent | |
| | +-------------------+ |
| | | feedback |
| | | with failure signal |
| | v |
+-------------------|-----------------------+------------------------+
v
Validated policy document
(e.g., YAML, XML, and JSON)
The main components of the Intent Translator (Scenario Extractor, Slot Extractor, Intent Composer, Policy Generator, Policy Validator, and trace driven recovery agent) are illustrated in Figure 1.¶
Together, these components support a transparent transformation of user-defined goals into system-aligned candidate policies that can be validated before downstream use. The architecture is modular and extensible, allowing domain-specific enhancements (such as substitution of the underlying language model, the constrained decoder, or the validator implementation) without modification to the end-to-end pipeline.¶
The two Extractors share the same natural language input but address cognitively distinct sub-tasks. The Scenario Extractor performs abstraction-level reasoning and taxonomy classification, determining how the intent maps to a coordinate in the role-scenario space. The Slot Extractor performs token-level pattern matching and schema-aware slot filling, identifying entity spans and structured values in the surface text. Decomposing these sub-tasks permits each inference to use a narrower task and schema-as-grammar specification. Any resulting reduction in translation errors requires evaluation.¶
Natural Language Intent
|
+-------------+-------------+
| |
v v
+--------------------+ +--------------------+
| Scenario Extractor | | Slot Extractor |
+--------------------+ +--------------------+
| |
v v
{role, scenario} {entities, slot values}
| |
+-------------+-------------+
|
v
+-------------------+
| Intent Composer |
+-------------------+
|
v
Policy Generator
The internal flow of the parallel extraction step is illustrated in Figure 2.¶
The two Extractors may share the underlying language model instance, differing only in their prompt and in the schema-as-grammar specification applied at decoding time. This sharing can keep the number of distinct model artifacts low and reduce the operational complexity of maintaining heterogeneous model families. The two inferences are independent, so they may be executed either sequentially on a single accelerator or concurrently when batched inference is supported by the runtime.¶
Parallel decomposition can be preferable to sequential decomposition (in which the output of the Scenario Extractor is injected as context to the Slot Extractor) for two reasons. First, parallel execution can reduce cascading errors from the Scenario Extractor into the Slot Extractor. Second, the two outputs may be cross-checked downstream, providing an additional consistency signal to the Policy Validator and the trace driven recovery agent.¶
Role separation is logical. The Extractors and Policy Generator provide language-model functions; the Semantic Judge may also use a language model. Intent Composer and the schema and relational validators provide deterministic processing or checking. These functions may share model instances and need not be deployed as independent agents. The agentic property described here is their bounded feedback-driven coordination.¶
The Policy Generator synthesizes a candidate policy document from the merged Intermediate JSON. The principal design constraint is that candidate output should remain within the structural language admitted by the target OpenAPI-derived schema grammar. This constraint is enforced through schema-as-grammar [Outlines][XGrammar][GCD], in which the schema is compiled into a schema-derived grammar consumed by the language model decoder. The general efficacy and known limitations of schema-as-grammar across heterogeneous schemas have been characterized in recent benchmarks [JSONSchemaBench]; not all schema features are expressible as efficient grammars, which is one reason post-generation validation remains part of the framework.¶
+---------------------+
| Intent Composer |
+----------+----------+
|
| Intermediate representation
v
+-----------------------------+
| Policy Generator |
| |
| +--------------------+ | +----------------+
| | Grammar Compiler |<---|---| Policy |
| +--------------------+ | | Knowledge Base |
| | | +--------=-------+
| v |
| +---------------------+ |
| | Constrained Decoder | |
| +---------------------+ |
+--------------+--------------+
|
| Candidate policy representation
v
Policy Validator
The internal workflow of the Policy Generator is illustrated in Figure 3.¶
Schema-as-grammar enforcement reduces syntactic invalidity (F-syn) by constraining the output language, but it does not, by itself, establish semantic coherence across slots. For example, a candidate document may satisfy every individual field constraint while combining an object type and a target name that are incompatible under the IntentExpectation type hierarchy of [TS-28.312]. Such cross-slot violations are detected downstream by the Policy Validator.¶
The Policy Generator may optionally be specialized through supervised adaptation, including Low-Rank Adaptation (LoRA) [LoRA]. The model, adaptation method, and any claimed reduction in translation errors are deployment and evaluation choices, not prerequisites or demonstrated guarantees of this architecture.¶
The Policy Validator evaluates schema conformance, cross-slot consistency, and faithfulness to the original intent as complementary dimensions. Its observations support diagnosis and recovery, but do not prove statistical independence of the checks, a unique upstream cause, or the absence of hallucination.¶
+---------------------+
| Policy Generator |
+----------+----------+
|
| candidate policy
v
+-----------------------------------------+
| Policy Validator |
| |
| +-------------------------------+ |
| | Schema Validator |<--- schema/profile
| | (schema shape) | |
| +---------------+---------------+ |
| | |
| v |
| +-------------------------------+ |
| | Semantic Solver |<--- invariants
| | (cross-slot) | |
| +---------------+---------------+ |
| | |
| v |
| +-------------------------------+ |
| | Semantic Judge |<--- intent/context
| | (intent faithfulness) | |
| +---------------+---------------+ |
| | |
+--------------------+--------------------+
|
v
{ pass | failure trace }
|
+---------+---------+
| |
pass | | fail + trace
| v
| +----------------+
| | Trace driven |
| | recovery agent |
v +----------------+
Validated policy
The internal architecture of the Policy Validator is shown in Figure 4. The checks execute in order and produce structured observations. Each check reports pass, fail, or not assessed, with a reason when assessment is uncertain, blocked by an earlier failure, or cannot be completed. A check that was not assessed is not treated as a pass. The declared acceptance policy determines the final disposition and any retry.¶
The labels F-syn, F-xs, F-sem, and F-val correspond to the four failure-mode categories defined in Section 2. The mapping associates each failure-mode category with its primary detecting sub-component: the Schema Validator emits F-syn and the schema-expressible portion of F-val; the Semantic Solver emits F-xs; and the Semantic Judge emits F-sem and the natural-language-context-dependent portion of F-val. F-val therefore has two detection paths, reflecting the practical observation that some value-range or unit errors are caught at the schema level while others require natural language context. The failure-mode trace produced by the Policy Validator is consumed by the trace driven recovery agent described in Section 3.5.¶
A deployment declares which checks are required or advisory and how their outcomes are combined. For example, acceptance may require the Schema Validator and Semantic Solver to pass and a semantic assessment to meet the stated criteria. A deterministic alternative to the Semantic Judge must cover those semantic criteria; lexical overlap alone is not an acceptance gate. Failed or unassessed required checks remain explicit and prevent a clean validation-success result. Advisory warnings and any acceptance with warnings are recorded separately from clean acceptance.¶
A logical validation trace should identify the intent and candidate, the candidate version, the schema/profile and relational-rule versions, each check and its outcome, applicable failure-mode labels, the affected fields, and references to available evidence. Recovery records should identify the selected retry target, attempt count, remaining budget, and final disposition. Evidence may include input spans or constraint identifiers; unavailable evidence is not fabricated. These are functional reporting requirements, not a new wire encoding or inter-agent protocol. Their coverage in a particular prototype must be verified separately.¶
When the Policy Validator emits a failure trace, the recovery-control function uses the observations and the configured policy to select a permitted corrective action. A trace can contain multiple failure labels, and the detecting component does not uniquely determine the originating cause. The controller may follow fixed routing rules; independently autonomous planning or a model-driven routing implementation is not required by this architecture.¶
+---------------------+
| Policy Validator |
+---------------------+
|
| failure-mode trace
v
+-----------------+
| Trace driven |
| recovery agent |
+-----------------+
|
+------------+-----+-----+------------+
| | | |
F-syn F-xs F-val F-sem*
(syntax) (cross-slot) (value) (meaning)
| | | |
v v v v
+---------+ +---------+ +---------+ +-----------+
| Policy | | Policy | | Slot | | Scenario |
|Generator| |Generator| |Extractor| | Extractor |
+---------+ +---------+ +---------+ +-----------+
* F-sem retries Policy Generator when the coordinate is correct.
(retry budget enforced; on exhaustion, a degraded intent is emitted)
One possible routing policy for the trace driven recovery agent is summarized in Figure 5 and described below. The mapping is a deployment policy and can be adjusted based on implementation experience and local validation data.¶
The trace driven recovery agent enforces a bounded retry budget. When the budget is exhausted without successful validation, the router emits a degraded intent that records the residual failure mode and the most recent candidate policy. Degraded intents are suitable for routing to a human operator or to a downstream validation pipeline before deployment.¶
The routing policy itself is subject to validation. A deployment should verify that a selected retry target is likely to reduce the observed failure mode and should update the routing table if local data indicates a different dominant cause. For example, an F-xs trace may be routed to the Policy Generator with an additional hard constraint when the role-and-scenario coordinate is trusted, but another deployment might route the same failure to re-extraction if the coordinate is uncertain.¶
Recovery preserves the original intent. When a Scenario or Slot Extractor result changes, the Intent Composer merges the updated outputs, the Policy Generator regenerates the candidate, and the applicable checks run again. Candidate versions and evidence remain correlated so that stale results are not reused as proof of a revised candidate's validity. The controller does not silently relax user requirements to obtain a pass. Ambiguous inputs and unresolved failures are returned with an explicit review-needed disposition. A deployment specifies its retry-count limit and any additional time or token limits; exhaustion terminates the workflow with the residual status recorded.¶
Policy artifacts are data instances serialized in formats supported by the target model, such as YAML [YAML], JSON, or XML. YANG [RFC6020][RFC7950] defines a data model rather than a serialization. NETCONF [RFC6241], RESTCONF [RFC8040], or REST [REST] may carry an artifact only through an appropriate model-specific encoding and interface binding; changing serialization alone does not provide a semantic mapping between models. For the 3GPP instantiation, validation uses the relevant schemas from the OpenAPI specification of [TS-28.312]. A deployment or evaluation identifies the exact schema version and artifact references, the selected role/scenario taxonomy, and the relational-rule set. This document does not define a new intent language or a new transport protocol.¶
As described in the modular architecture of the framework, user-defined natural language intent is processed through a partially parallel pipeline that includes the Scenario Extractor, the Slot Extractor, the Policy Generator, the Policy Validator, and the trace driven recovery agent. The schema and the cross-slot relational invariants are sourced from the Policy Knowledge Base, enabling schema-as-grammar enforcement and failure-mode-specific detection. This design is intended to help translate operational goals - even when imprecisely expressed - into policy representations that can be checked for schema conformance, cross-slot coherence, and semantic faithfulness to the user's intent.¶
Therefore, this document defines a practical and extensible architecture for intent translation in management systems. Through this architecture, high-level user goals can be mapped to structured policy outputs that are suitable for validation and downstream automation. The framework enables intent-based management to support scalable, knowledge-grounded automation in complex service domains such as networks, vertical-specific networks, and intelligent edge infrastructures.¶
This document does not require any IANA actions.¶
The deployment of the Intent Translator Framework requires alignment between the Policy Knowledge Base and the operational policies supported by the underlying infrastructure. The schema of the target standard, examples of valid policy documents, and the relational invariants between schema fields must be encoded within the Policy Knowledge Base so that schema-as-grammar enforcement, few-shot retrieval, and cross-slot validation are consistent with the deployment environment.¶
Operators should validate the framework against representative intents and reference policies before enabling full automation. In particular, the routing table of the trace driven recovery agent should be calibrated using local failure traces and operational policy. The default routing policy described in Section 3.5 is a starting point and may need to be adjusted based on deployment data.¶
The computational requirements depend on the selected language models, constrained decoder, and validator implementation. Inference for the two Extractors and the Policy Generator can be served from a small number of accelerators when the underlying language models are of moderate size. The Schema Validator and the Semantic Solver are deterministic and inexpensive. The Semantic Judge, when realized as a language model, dominates the validator's computational cost, and may be replaced or supplemented by deterministic checks in latency-sensitive deployments. When the framework is deployed in a 5G system context [TS-23.501], the resulting policy documents are consumed by the Intent Driven Management Service (IDM-MnS) defined in [TS-28.312].¶
The deployed model and prompt versions, schema/profile, relational rules, and acceptance policy should be recorded with translation results. The reporting and disposition conventions described here are implementation requirements to be checked, not evidence that every preliminary prototype already implements them.¶
The modular architecture of the framework allows individual components - such as the Scenario Extractor, the Slot Extractor, the Policy Generator, or any sub-component of the Policy Validator - to be adapted to different domains, languages, or knowledge representations. As such, implementers can substitute the language model, modify the schema-as-grammar specification, or replace the output schema (e.g., YAML, XML, JSON) without altering the end-to-end pipeline.¶
The framework separates the pipeline from its domain profile. Schema evolution can require updates to the role/scenario taxonomy, examples, relational invariants, grammar compiler, and validator configuration as well as grammar recompilation. Compatibility with another release of [TS-28.312] or another domain must be checked through profile-specific validation and regression tests; it is not guaranteed by recompilation alone.¶
The Policy Knowledge Base may be extended over time with new examples, new entity types, and new relational invariants to support evolving service capabilities. Such extensions should preserve backward compatibility by maintaining stable identifiers for core operational concepts.¶
When the retry budget is exhausted without satisfying the required checks, the framework returns a degraded intent containing residual failures or unresolved assessments and the most recent candidate. Implementations distinguish clean acceptance, acceptance with advisory warnings, review-needed degradation, and rejection in their result metadata. These dispositions describe the configured checks and policy; none is a general proof that a policy is free of hallucination or operationally safe.¶
For high-assurance environments, degraded intents should be reviewed by a human operator or routed to a validation pipeline before policy deployment. Logging mechanisms should be used to record degraded cases, the residual failure modes, and their resolution outcomes, so that future iterations of the Policy Knowledge Base, the routing table, and any supervised specialization of the Policy Generator can incorporate the observed cases.¶
Because the Semantic Judge has calibration limits, a deployment may designate particular F-sem observations as advisory under an explicit, evaluated acceptance policy. If that policy permits acceptance with warnings after schema and relational checks pass, the warning and decision remain attached to the candidate and are reported separately in evaluation. An exception for an advisory observation does not convert a failed or unassessed required semantic check into a pass. High-assurance environments should obtain human or downstream validation before deploying degraded candidates.¶
The Intent Translation Framework must operate over authenticated and confidential channels (e.g., TLS/HTTPS) to prevent eavesdropping, message tampering, or replay attacks by malicious actors. Implementations should enforce strict certificate validation and regularly rotate cryptographic keys to maintain transport-layer security.¶
Because the system processes free-form natural language intents, it is vulnerable to adversarially crafted inputs designed to produce unintended or harmful policies. Schema-as-grammar enforcement bounds the space of syntactically possible outputs, and the cross-slot Semantic Solver bounds the space of structurally coherent outputs, but neither prevents an adversary from issuing a semantically harmful intent that is nonetheless schema-valid and cross-slot coherent. Deployments should incorporate input validation, semantic sanity checks, and confirmation interfaces for high-impact operations, and should rate-limit or quarantine suspicious requests for manual review.¶
Deployments that use language-model components should also consider prompt-injection and instruction-confusion attacks. Inputs, retrieved examples, and schema descriptions should be separated by clear trust boundaries, and implementations should avoid allowing user-provided text to override validator, authorization, or deployment policies.¶
Policy generation should be bound to an authorization model. A policy that is schema-valid and semantically faithful to an input intent may still exceed the authority of the requesting principal or may have an unacceptable operational blast radius. High-impact candidate policies should therefore be subject to approval, rollback, and audit procedures before enforcement.¶
Intent collisions, in which contradictory or overlapping intents are submitted concurrently, can lead to policy conflicts or enforcement gaps. The framework must include conflict-detection logic that examines the relations between successive policy documents, and either automatically resolves detected collisions using a documented precedence model or escalates them to human operators for arbitration.¶
When the Policy Generator is specialized through supervised adaptation, the training corpus must be protected against poisoning. An adversary that injects malicious intent-policy pairs into the training corpus could bias the Policy Generator toward emitting policies that are schema-valid but operationally harmful. Implementations should record the provenance of each training example and should validate that supervised adaptation does not regress the framework's behavior on a held-out test set of known-good intents.¶
Schemas, relational rules, retrieved evidence, and validation traces influence both generation and acceptance decisions. Their provenance, versions, and integrity should be protected, and examples should not be promoted to authoritative facts about a request. Hallucination mitigation does not replace authorization, operational safety checks, or downstream assurance.¶
This section is included to provide an indication of implementation status, consistent with [RFC7942]. It does not constitute an endorsement by the IETF or the IRTF, and it is expected to be removed or updated before publication as an RFC.¶
A research prototype of the framework has been exercised using publicly available components: an open-weight language model for the Extractors and Policy Generator, a constrained-decoding engine for schema-derived generation constraints, a JSON Schema validator for schema-level checks, and an SMT solver for selected cross-slot invariants. The prototype used the OpenAPI specification of 3GPP TS 28.312 (as of Release 19) as the target schema source.¶
Preliminary experiments were performed on a small synthesized data set of natural language intents and reference policy representations, derived from the OpenAPI schema via template-based synthesis and augmented by paraphrastic methods. The experiments were used to compare a single-extractor baseline with the parallel-extractor and validation-routing design described in this document. The observations suggest that parallel extraction and cross-slot validation reduce several classes of residual errors, especially cross-slot inconsistency. These results are preliminary and do not constitute a generalization claim; the data set and evaluation harness are not yet sufficient for that purpose.¶
A future revision is expected to identify the prototype repository, the data set generation method, the exact schema version, and the evaluation harness once those artifacts are made publicly available.¶
The preliminary description above does not establish implementation coverage of every reporting, disposition, or recovery convention clarified in this revision. It does not establish a quantified hallucination reduction rate, an advantage of agentic or model-directed routing over a fixed policy, cross-domain or cross-model generalization, or correctness of deployed network behavior. Those claims require additional implementation evidence and evaluation; the following considerations are an evaluation design, not reported results.¶
Future evaluations should compare a single translation call, schema-constrained generation, validation with generic retry, and the described failure-directed recovery, using comparable models, inputs, and call or token budgets. If model-directed routing is implemented, its effect should be isolated by comparison with fixed routing under otherwise matched conditions. Separating outcome and process measures follows the evaluation perspective in [I-D.cui-nmrg-llm-benchmark].¶
Report residual semantic errors or hallucinations among accepted policies, erroneous acceptance, detection and recovery outcomes by failure mode, clean-acceptance coverage, warning/review/rejection rates, and latency and token or call cost. Error rates must be reported with acceptance coverage so that rejecting every input is not mistaken for successful mitigation. The Semantic Judge's own output is not the evaluation oracle; use independent reference constraints, validated policies, or expert assessments. Translation-quality measures do not by themselves establish operational intent fulfillment.¶
This document is a product of the NMRG including the RG Chairs (Jerome Francois and Jeferson Campos Nobre). This document benefitted from the review and comments from the following people: Jung-Soo Park, Yong-Geun Hong, and Joo-Sang Youn. The authors sincerely appreciate their sincere efforts and kind help.¶
This work was supported by Institute of Information & Communications Technology Planning & Evaluation (IITP) grant funded by the Korea Ministry of Science and ICT (MSIT) (No. RS-2024-00398199 and RS-2022-II221015).¶
This work was supported in part by Institute of Information & Communications Technology Planning & Evaluation (IITP) grant funded by the Korea Ministry of Science and ICT (MSIT) (No. 2025-RS-2022-II221199, Regional strategic industry convergence security core talent training business).¶
The following are coauthors of this document:¶
The following changes are made from draft-gu-nmrg-intent-translator-04:¶