Internet Research Task Force M. Gu, Ed.
Internet-Draft J. Jeong, Ed.
Intended status: Informational K. Shim
Expires: 6 May 2027 Sungkyunkwan University
2 November 2026
An Agentic AI Framework for Hallucination Mitigation in Network Intent
Translation
draft-gu-nmrg-intent-translator-04
Abstract
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.
Status of This Memo
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 6 May 2027.
Gu, et al. Expires 6 May 2027 [Page 1]
Internet-Draft Intent Translation and Validation November 2026
Copyright Notice
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.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1. Scope and Limitations . . . . . . . . . . . . . . . . . . 4
1.2. Relationship to Other Work . . . . . . . . . . . . . . . 5
2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 5
3. Intent Translator Framework Architecture . . . . . . . . . . 8
3.1. Intent Translator . . . . . . . . . . . . . . . . . . . . 8
3.2. Parallel Extractor Decomposition . . . . . . . . . . . . 12
3.3. Policy Generator . . . . . . . . . . . . . . . . . . . . 14
3.4. Policy Validator . . . . . . . . . . . . . . . . . . . . 16
3.5. trace driven recovery agent . . . . . . . . . . . . . . . 19
3.6. Standardized Data Models and Interfaces . . . . . . . . . 21
4. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 22
5. Deployment Considerations . . . . . . . . . . . . . . . . . . 22
6. Extensibility Considerations . . . . . . . . . . . . . . . . 23
7. Degradation and Human Oversight Considerations . . . . . . . 24
8. Security Considerations . . . . . . . . . . . . . . . . . . . 24
9. Implementation Status . . . . . . . . . . . . . . . . . . . . 26
9.1. Evaluation Considerations . . . . . . . . . . . . . . . . 27
10. References . . . . . . . . . . . . . . . . . . . . . . . . . 27
10.1. Normative References . . . . . . . . . . . . . . . . . . 27
10.2. Informative References . . . . . . . . . . . . . . . . . 28
Appendix A. Acknowledgments . . . . . . . . . . . . . . . . . . 32
Appendix B. Contributors . . . . . . . . . . . . . . . . . . . . 32
Changes from draft-gu-nmrg-intent-translator-03 . . . . . . . . . 33
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 33
1. Introduction
The increasing scale and heterogeneity of networks and services make
manual policy configuration and management increasingly difficult.
Gu, et al. Expires 6 May 2027 [Page 2]
Internet-Draft Intent Translation and Validation November 2026
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 a framework for detecting and mitigating
structural and semantic errors in the translation of a natural-
language network intent into structured policies. 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:
* Scenario Extractor: It classifies an input intent along two axes -
the management role (e.g., service customer, service provider, or
network operator) and the deployment scenario (e.g., radio
network, radio service, edge service support, or 5G core network)
- producing a coordinate that routes downstream processing.
* Slot Extractor: It extracts entities and structured slot values
(e.g., target name, target value, target unit, and target
condition) from the same natural language input, in parallel with
the Scenario Extractor.
Gu, et al. Expires 6 May 2027 [Page 3]
Internet-Draft Intent Translation and Validation November 2026
* Intent Composer: It merges the outputs of the two Extractors into
a single structured intermediate representation that the Policy
Generator consumes.
* Policy Generator: It synthesizes a candidate policy document,
typically serialized as YAML or JSON, under schema-as-grammar
constraints derived from the target schema.
* Policy Validator: It evaluates the candidate policy along three
dimensions: schema validity, cross-slot semantic invariants, and
semantic faithfulness to the original natural language input. It
produces a failure-mode trace when violations occur.
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.
1.1. Scope and Limitations
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.
Gu, et al. Expires 6 May 2027 [Page 4]
Internet-Draft Intent Translation and Validation November 2026
1.2. Relationship to Other Work
The framework addresses the intent-translation function discussed in
[RFC9315] and [I-D.irtf-nmrg-ibn-usecases]. It focuses on errors
within the translation workflow, while downstream orchestration and
operational assurance remain separate functions. The broader
application of agentic AI to the IBN lifecycle and network management
is discussed in [I-D.cxxx-nmrg-ai4ibn] and
[I-D.hong-nmrg-agenticai-ps]. This document uses a bounded workflow
definition of agentic behavior rather than prescribing a general
autonomous-agent architecture.
Model specialization and adapter composition are discussed in
[I-D.cgfabk-nmrg-ibn-generative-ai]. The present framework instead
focuses on validation evidence and recovery of candidate policy
artifacts, regardless of whether the underlying model is specialized.
Human review and audit of LLM-assisted network-management decisions
are addressed in [I-D.cui-nmrg-llm-nm]; degraded translation results
can be handed to such review processes. The separation of outcome
and process metrics in [I-D.cui-nmrg-llm-benchmark] informs the
proposed evaluation considerations, without implying that this
framework has demonstrated end-to-end network configuration
correctness. These Internet-Drafts are work in progress and do not
provide a universal normative definition of agentic AI.
2. Terminology
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:
* Intent: A set of operational goals (that a network should meet)
and outcomes (that a network is supposed to deliver), defined in a
declarative manner without specifying how to achieve or implement
them [RFC9315].
Gu, et al. Expires 6 May 2027 [Page 5]
Internet-Draft Intent Translation and Validation November 2026
* Intent-Based Management (IBM): It enforces an intent from a user
(or administrator) into a target system. An intent can be
expressed as a natural language sentence and translated into a
high-level policy using natural language interpretation and
structured policy mapping
[I-D.jeong-nmrg-security-management-automation], [SPT]. This
high-level policy is then transformed into low-level policies that
are dispatched to appropriate Service Functions (SFs). Based on
monitoring feedback, new rules may be generated or existing
policies refined.
* Agentic Workflow: A coordinated translation process in which role-
specialized language-model functions use structured validation
feedback to revise intermediate representations or candidate
policies under a bounded recovery policy. The term describes
system-level feedback-driven behavior and does not prescribe
independently autonomous agents, separate model instances, or a
particular inter-agent protocol. Fixed routing policies and
model-assisted selection are implementation choices; model-
assisted planning is not required or claimed as an implemented
capability by this document.
* Translation Hallucination: Generated policy content that asserts
entities, attributes, relationships, or target values that are
unsupported by or inconsistent with the input intent and
explicitly supplied authoritative context, including declared
schema rules and authorized defaults. Failure modes describe
observed defects; a validation failure alone is not proof of
hallucination or of a particular generating cause.
* Scenario Extractor: A logical function that receives a natural
language input from the user or operator and classifies it along
two axes: the management role (e.g., Communication Service
Customer, Communication Service Provider, or Network Operator, as
defined in 3GPP [TS-28.530]) and the deployment scenario (e.g.,
RadioNetwork, RadioService, EdgeServiceSupport, or 5GCNetwork,
corresponding to the IntentExpectation subclasses defined in 3GPP
[TS-28.312]). The output is a coordinate that constrains
downstream component behavior.
* Slot Extractor: A logical function that, in parallel with the
Scenario Extractor and given the same natural language input,
extracts named entities and structured slot values (such as target
name, target value, target unit, and target condition) required to
populate the policy document.
Gu, et al. Expires 6 May 2027 [Page 6]
Internet-Draft Intent Translation and Validation November 2026
* Intent Composer: A logical function that merges the outputs of the
Scenario Extractor and the Slot Extractor into a single structured
intermediate representation (typically a JSON document) consumed
by the Policy Generator. The Intent Composer is a deterministic,
schema-shaped aggregation step and does not itself perform
language understanding.
* Policy Generator: A logical function that produces a machine-
readable policy document, typically in a format such as YAML or
JSON, from the merged outputs of the Scenario Extractor and the
Slot Extractor. The Policy Generator operates under schema-as-
grammar constraints that constrain per-token decoding against the
target schema, such as that defined in 3GPP [TS-28.312].
* Policy Validator: A logical function that evaluates a candidate
policy document along three dimensions: (i) schema validity
against the OpenAPI specification of the target standard, (ii)
cross-slot semantic invariants such as the relation between object
type and target name, and (iii) semantic faithfulness between the
original natural language intent and the candidate policy. The
Policy Validator emits a failure-mode trace identifying which
dimension(s), if any, were violated.
* Trace driven recovery agent: A logical recovery-control function
that consumes the Policy Validator's failure trace and selects
permitted regeneration, re-extraction, or termination actions
under a configured policy. The name denotes its role in the
agentic workflow and does not require an independently autonomous
or language-model-based controller.
* Policy Knowledge Base: A repository that maintains domain-specific
knowledge used during translation, including the schema of the
target standard, examples of valid policy documents (such as those
provided in informative annexes of 3GPP [TS-28.312]), and the
relational invariants between schema fields (such as the mapping
from object type to the set of valid target names). The Policy
Knowledge Base supports schema-as-grammar compilation, few-shot
retrieval, and cross-slot constraint checking.
* Schema-as-Grammar: A constrained-decoding technique that compiles
a target schema (such as an OpenAPI specification or a JSON
Schema) into a schema-derived grammar consumed by a language model
decoder, so that each token continuation is constrained to keep
the partial output extendable to a schema-admissible completion
[Outlines][XGrammar][GCD][JSONSchemaBench]. The expressiveness of
this grammar depends on the constrained-decoding implementation;
not all schema features are expressible as efficient grammars, and
post-generation validation is therefore still necessary. Schema-
Gu, et al. Expires 6 May 2027 [Page 7]
Internet-Draft Intent Translation and Validation November 2026
as-grammar may be applied at multiple levels, including the
intermediate JSON representation produced by the Extractors and
the candidate policy document produced by the Policy Generator.
* Failure Modes: Four complementary categories of observed intent-
to-policy translation failure: (i) F-syn, syntactic or schema
invalidity; (ii) F-sem, semantic mis-grounding or unfaithfulness
to the original intent; (iii) F-val, value-range or unit errors;
and (iv) F-xs, cross-slot inconsistency. Categories can co-occur,
and a trace can carry multiple labels. A detecting component does
not by itself establish the originating cause. F-val may be
detected at the schema level or through comparison with the
original intent. Not every structural defect or value-conversion
error is a translation hallucination.
* Degraded Intent: A translation result returned when the retry
budget is exhausted without satisfying the configured required
checks. It records the residual failures or unresolved
assessments and the most recent candidate policy. Its status
remains explicit when it is passed to a human operator or a
downstream validation pipeline; schema conformity alone does not
establish that the result is semantically faithful or free of
hallucination.
3. Intent Translator Framework Architecture
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.
3.1. Intent Translator
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].
Gu, et al. Expires 6 May 2027 [Page 8]
Internet-Draft Intent Translation and Validation November 2026
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.
Gu, et al. Expires 6 May 2027 [Page 9]
Internet-Draft Intent Translation and Validation November 2026
+----------+
| IBN User |
+----------+
|
| natural language intent
v
+--------------------------------------------------------------+
| Intent Translator |
| |
| +---------------------+ +---------------------+ |
| | Scenario Extractor | | Slot Extractor | |
| +---------------------+ +---------------------+ |
| | | |
| | (parallel inference) | |
| +-------------+--------------+ |
| | |
| v |
| +---------------------+ |
| | Intent Composer | |
| +---------------------+ |
| | |
| v |
| +---------------------+ +----------------+ |
| | Policy Generator |<-| Policy | |
| +---------------------+ | Knowledeg Base | |
| | +----------------+ |
| v |
| +---------------------+ |
| | Policy Validator | |
| +---------------------+ |
| | |
| pass | fail (with trace) |
| +------------+------------+ |
| | v |
| | +-------------------+ |
| | | Trace driven | |
| | | recovery agent | |
| | +-------------------+ |
| | | |
| | v |
| | targeted retry |
+---------------|----------------------------------------------+
v
Validated YAML
policy document
Gu, et al. Expires 6 May 2027 [Page 10]
Internet-Draft Intent Translation and Validation November 2026
Figure 1: Intent Translator Component Architecture
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.
* Scenario Extractor: A component that classifies the input intent
into a structural coordinate. In the 3GPP-based instantiation
described here, the role is selected from Communication Service
Customer (CSC), Communication Service Provider (CSP), and Network
Operator (NOP), as defined in [TS-28.530]. The scenario is
selected from four IntentExpectation subclasses in [TS-28.312]:
RadioNetwork, RadioService, EdgeServiceSupport, and 5GCNetwork.
These selected roles and scenarios form twelve cells that
constrain downstream policy choices for this instantiation.
Schema-as-grammar constraints restrict the output to this
configured set; it is not a universal classification of network-
management intent.
* Slot Extractor: A component that, in parallel with the Scenario
Extractor and given the same natural language input, extracts
named entities (such as area codes, user groups, or service
identifiers) and structured slot values required to populate the
policy document. Typical slots include target name, target value,
target unit, and target condition. The Slot Extractor is also
realized under schema-as-grammar constraints, so that entity types
and slot enumerations (such as units and comparison conditions)
are restricted to valid values at decoding time.
* Intent Composer: A component that merges the outputs of the two
Extractors into a single structured intermediate representation
(the Intermediate JSON) that the Policy Generator consumes. The
Intent Composer performs a deterministic, schema-shaped
aggregation - it does not itself perform language understanding.
* Policy Generator: A component that synthesizes a candidate policy
document. It consumes the merged Intermediate JSON produced by
the two Extractors and emits a candidate policy document,
typically in YAML, that targets the schema defined in [TS-28.312].
The Policy Generator operates under schema-as-grammar constraints
derived from the target OpenAPI specification, limiting token
continuations to those admitted by the compiled grammar. Post-
generation validation remains necessary because not all semantic
or cross-slot constraints are expressible in the generation
grammar. Optionally, the Policy Generator may be specialized to
the target domain through supervised adaptation, for example by
parameter-efficient fine-tuning over a corpus of intent-policy
pairs.
Gu, et al. Expires 6 May 2027 [Page 11]
Internet-Draft Intent Translation and Validation November 2026
* Policy Validator: A component that evaluates the candidate policy
along three complementary dimensions and emits a failure-mode
trace. The three sub-components are described in Section 3.4.
Unlike a single pass/fail check, the failure-mode trace identifies
which structural or semantic invariant was violated, enabling the
trace driven recovery agent to take a targeted corrective action.
* Trace driven recovery agent: A component that consumes the
failure-mode trace from the Policy Validator and dispatches
targeted regeneration. The router supports failure-mode-specific
corrective actions, such as regenerating the policy under
additional structural constraints when a cross-slot violation is
detected, or re-extracting slot values when a value-range
violation is detected. The router enforces a bounded retry budget
and emits a degraded intent if the budget is exhausted without
successful validation.
* Policy Knowledge Base: A repository component that supplies domain
knowledge consumed by the other components. It maintains the
schema of the target standard (used by the Policy Generator for
schema-as-grammar compilation), examples of valid policy documents
(used for few-shot retrieval), and the relational invariants
between schema fields (used by the Policy Validator for cross-slot
consistency checking). The Policy Knowledge Base may be extended
over time as new schema versions and new examples become
available.
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.
3.2. Parallel Extractor Decomposition
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.
Gu, et al. Expires 6 May 2027 [Page 12]
Internet-Draft Intent Translation and Validation November 2026
Natural Language Intent
|
+-------------+-------------+
| |
v v
+--------------------+ +--------------------+
| Scenario Extractor | | Slot Extractor |
+--------------------+ +--------------------+
| |
v v
{role, scenario} {entities, slot values}
| |
+-------------+-------------+
|
v
+-------------------+
| Intent Composer |
+-------------------+
|
v
Policy Generator
Figure 2: Parallel Extractor Decomposition
The internal flow of the parallel extraction step is illustrated in
Figure 2.
* Scenario Extractor: In this 3GPP-based instantiation, the logical
function selects one of the three management roles (CSC, CSP, NOP)
and one of four selected IntentExpectation subclasses
(RadioNetwork, RadioService, EdgeServiceSupport, 5GCNetwork). The
selected roles and scenarios define twelve permitted (role,
scenario) combinations. Decoding is constrained to emit one of
these combinations, recorded as a small JSON object.
* Slot Extractor: A logical function that, in parallel with the
Scenario Extractor and from the same natural language input,
identifies the named entities (such as area codes, user groups, or
service identifiers) and the structured slot values (target name,
target value, target unit, target condition) that the policy will
carry. Slot values are constrained at decoding time to belong to
valid enumerations (for example, a closed set of comparison
conditions and a closed set of units), so that downstream schema
validation cannot fail on out-of-vocabulary slots.
Gu, et al. Expires 6 May 2027 [Page 13]
Internet-Draft Intent Translation and Validation November 2026
* Intent Composer: A deterministic step that merges the two
Extractor outputs into a single Intermediate JSON document of the
form {role, scenario, entities, slot values}. The Intent Composer
does not invoke a language model. The two Extractors operate on
the same input independently, so any cross-output inconsistency
that may arise is left to the Policy Validator to detect
downstream.
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.
3.3. Policy Generator
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.
Gu, et al. Expires 6 May 2027 [Page 14]
Internet-Draft Intent Translation and Validation November 2026
+---------------------+
| Intent Composer |
+----------+----------+
|
| Intermediate representation
v
+-----------------------------+
| Policy Generator |
| |
| +--------------------+ | +----------------+
| | Grammar Compiler |<---|---| Policy |
| +--------------------+ | | Knowledge Base |
| | | +--------=-------+
| v |
| +---------------------+ |
| | Constrained Decoder | |
| +---------------------+ |
+--------------+--------------+
|
| Candidate policy representation
v
Policy Validator
Figure 3: Policy Generator Internal Workflow
The internal workflow of the Policy Generator is illustrated in
Figure 3.
* Grammar Compiler: A component that compiles the target schema,
such as the OpenAPI-derived schema of [TS-28.312], into a grammar
supported by the constrained decoder. It reads the schema from
the Policy Knowledge Base. Reference resolution and normalization
of constructs such as discriminator, allOf, and oneOf may be
necessary, but transformations must preserve the relevant source
constraints; replacing allOf by oneOf is not a general
equivalence. Constraints not enforced by the compiled grammar
remain subject to post-generation validation, and the
implementation should identify the supported constraint subset.
* Constrained Decoder: A component that runs the language model with
the compiled grammar applied at every decoding step. At each
step, the grammar restricts the set of token continuations to
those that keep the partial output extendable to a schema-
admissible completion. The Constrained Decoder consumes the
Intermediate JSON produced by the Intent Composer and emits the
candidate policy document.
Gu, et al. Expires 6 May 2027 [Page 15]
Internet-Draft Intent Translation and Validation November 2026
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.
3.4. Policy Validator
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.
Gu, et al. Expires 6 May 2027 [Page 16]
Internet-Draft Intent Translation and Validation November 2026
+---------------------+
| 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
Figure 4: Policy Validator Internal Architecture
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,
Gu, et al. Expires 6 May 2027 [Page 17]
Internet-Draft Intent Translation and Validation November 2026
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.
* Schema Validator (syntax check): This sub-component checks the
candidate instance against the selected target schema. A YAML
candidate is first parsed and, where needed, normalized to the
data representation expected by the validator. The relevant
schemas and external references are resolved from the OpenAPI
specification, with any dialect adaptation required by the chosen
JSON Schema validator, such as a Draft 2020-12 implementation
[JSON-Schema-2020-12]. It detects F-syn and schema-expressible
F-val. Schema compilation or resolution failures are reported as
configuration or assessment failures, rather than attributed
automatically to hallucination. Grammar enforcement does not
remove the need for these checks.
* Semantic Solver (cross-slot check): This sub-component checks
configured relational and domain constraints not fully captured or
enforced by the selected schema and generation grammar. For the
described 3GPP instantiation, these include the permitted
relationship between object type and target name. A
Satisfiability Modulo Theories (SMT) solver such as Z3 [Z3] may
implement these checks and report F-xs. A solver result applies
only to the encoded constraints and does not establish correctness
of facts outside the supplied context.
* Semantic Judge (meaning check): This sub-component evaluates the
semantic faithfulness between the original natural language intent
and the candidate policy document. It detects semantic mis-
grounding (F-sem), such as the selection of a schema branch that
is structurally valid but does not match the user's stated goal,
and the portion of value-range errors (F-val) that depend on
natural language context. The Semantic Judge may be realized as a
language model judge with calibrated few-shot examples, optionally
supplemented by deterministic lexical overlap checks for
robustness. An LLM-based assessment can be incorrect or uncertain
and is not ground truth. Lexical overlap may supply diagnostic
evidence, but is not sufficient by itself to establish
faithfulness.
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
Gu, et al. Expires 6 May 2027 [Page 18]
Internet-Draft Intent Translation and Validation November 2026
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.
3.5. trace driven recovery agent
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.
Gu, et al. Expires 6 May 2027 [Page 19]
Internet-Draft Intent Translation and Validation November 2026
+---------------------+
| 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)
Figure 5: trace driven recovery agent Failure-Mode Dispatch
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.
* F-syn (syntactic invalidity): Route to the Policy Generator for
regeneration. This case may occur when the generation constraints
are incomplete, miscompiled, or not fully aligned with the
validator used after generation.
* F-xs (cross-slot inconsistency): Route to the Policy Generator
with additional configured constraints or corrective guidance,
such as binding the object type to a trusted (role, scenario)
coordinate. A prompt directive provides guidance; a hard
constraint requires enforcement by the generation grammar or a
validation tool.
* F-val (value-range error): Route to the Slot Extractor for re-
extraction of the affected slot values.
Gu, et al. Expires 6 May 2027 [Page 20]
Internet-Draft Intent Translation and Validation November 2026
* F-sem (semantic mis-grounding): Route to the Scenario Extractor if
the failure trace indicates an incorrect (role, scenario)
coordinate; otherwise route to the Policy Generator with an
additional semantic hint. In some deployments, F-sem alone may
not justify retry because the Semantic Judge has inherent
calibration limits.
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.
3.6. Standardized Data Models and Interfaces
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
Gu, et al. Expires 6 May 2027 [Page 21]
Internet-Draft Intent Translation and Validation November 2026
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.
4. IANA Considerations
This document does not require any IANA actions.
5. Deployment Considerations
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
Gu, et al. Expires 6 May 2027 [Page 22]
Internet-Draft Intent Translation and Validation November 2026
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.
6. Extensibility Considerations
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.
Gu, et al. Expires 6 May 2027 [Page 23]
Internet-Draft Intent Translation and Validation November 2026
7. Degradation and Human Oversight Considerations
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.
8. Security Considerations
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.
Gu, et al. Expires 6 May 2027 [Page 24]
Internet-Draft Intent Translation and Validation November 2026
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.
Gu, et al. Expires 6 May 2027 [Page 25]
Internet-Draft Intent Translation and Validation November 2026
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.
9. Implementation Status
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.
Gu, et al. Expires 6 May 2027 [Page 26]
Internet-Draft Intent Translation and Validation November 2026
9.1. Evaluation Considerations
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.
10. References
10.1. Normative References
[RFC6020] Bjorklund, M., "YANG - A Data Modeling Language for the
Network Configuration Protocol (NETCONF)", RFC 6020,
DOI 10.17487/RFC6020, October 2010,
<https://www.rfc-editor.org/rfc/rfc6020>.
[RFC6241] Enns, R., Bjorklund, M., Schoenwaelder, J., and A.
Bierman, "Network Configuration Protocol (NETCONF)",
RFC 6241, DOI 10.17487/RFC6241, June 2011,
<https://www.rfc-editor.org/rfc/rfc6241>.
[RFC7950] Bjorklund, M., "The YANG 1.1 Data Modeling Language",
RFC 7950, DOI 10.17487/RFC7950, August 2016,
<https://www.rfc-editor.org/rfc/rfc7950>.
[RFC8040] Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF
Protocol", RFC 8040, DOI 10.17487/RFC8040, January 2017,
<https://www.rfc-editor.org/rfc/rfc8040>.
[RFC8329] Lopez, D., Lopez, E., Dunbar, L., Strassner, J., and R.
Kumar, "Framework for Interface to Network Security
Functions", RFC 8329, DOI 10.17487/RFC8329, February 2018,
<https://www.rfc-editor.org/rfc/rfc8329>.
Gu, et al. Expires 6 May 2027 [Page 27]
Internet-Draft Intent Translation and Validation November 2026
[RFC9315] Clemm, A., Ciavaglia, L., Granville, L., and J. Tantsura,
"Intent-Based Networking - Concepts and Definitions",
RFC 9315, DOI 10.17487/RFC9315, October 2022,
<https://www.rfc-editor.org/rfc/rfc9315>.
10.2. Informative References
[RFC7942] Sheffer, Y. and A. Farrel, "Improving Awareness of Running
Code: The Implementation Status Section", RFC 7942,
DOI 10.17487/RFC7942, July 2016,
<https://www.rfc-editor.org/rfc/rfc7942>.
[I-D.ietf-i2nsf-applicability]
Jeong, J., Hyun, S., Ahn, T., Hares, S., and D. Lopez,
"Applicability of Interfaces to Network Security Functions
to Network-Based Security Services", Work in Progress,
Internet-Draft, draft-ietf-i2nsf-applicability-18, January
2022, <https://datatracker.ietf.org/doc/draft-ietf-i2nsf-
applicability/>.
[I-D.jeong-nmrg-security-management-automation]
Jeong, J., Lingga, P., and Y. Ahn, "An Extensible Security
Management Automation Framework Based on Intent-Based
Networking", Work in Progress, Internet-Draft, draft-
jeong-nmrg-security-management-automation, March 2025,
<https://datatracker.ietf.org/doc/draft-jeong-nmrg-
security-management-automation/>.
[I-D.jeong-nmrg-ibn-network-management-automation]
Jeong, J., Oh, Y., Choi, J., and Y. Ahn, "Intent-Based
Network Management Automation in 5G Networks", Work in
Progress, Internet-Draft, draft-jeong-nmrg-ibn-network-
management-automation, March 2025,
<https://datatracker.ietf.org/doc/draft-jeong-nmrg-ibn-
network-management-automation/>.
[SPT] Lingga, P., Jeong, J., Yang, J., and J. Kim, "SPT:
Security Policy Translator for Network Security Functions
in Cloud-Based Security Services", IEEE Transactions on
Dependable and Secure Computing, Volume 21, Issue 6,
DOI https://doi.org/10.1109/TDSC.2024.3371788, November
2024, <https://doi.org/https://doi.org/10.1109/
TDSC.2024.3371788>.
[YAML] Ben-Kiki, O., Evans, C., and I. Net, "YAML Ain't Markup
Language (YAML) Version 1.2.2",
Available: https://yaml.org/spec/1.2.2/, October 2021.
Gu, et al. Expires 6 May 2027 [Page 28]
Internet-Draft Intent Translation and Validation November 2026
[TS-23.501]
"System Architecture for the 5G System (5GS)", Available:
https://portal.3gpp.org/desktopmodules/Specifications/
SpecificationDetails.aspx?specificationId=3144, June 2025.
[TS-28.312]
"Intent Driven Management Services for Mobile Networks",
Available:
https://portal.3gpp.org/desktopmodules/Specifications/
SpecificationDetails.aspx?specificationId=3554, November
2025.
[TS-28.530]
"Management and orchestration; Concepts, use cases and
requirements", Available:
https://portal.3gpp.org/desktopmodules/Specifications/
SpecificationDetails.aspx?specificationId=3273, June 2025.
[TR-28.812]
"Study on Scenarios for Intent Driven Management Services
for Mobile Networks", Available:
https://portal.3gpp.org/desktopmodules/Specifications/
SpecificationDetails.aspx?specificationId=3553, December
2020.
[REST] Fielding, R., "Architectural Styles and the Design of
Network-based Software Architectures", Ph.D. Dissertation,
University of California, Irvine, Available:
https://www.ics.uci.edu/~fielding/pubs/dissertation/
top.htm, 2000.
[LoRA] Hu, E., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang,
S., Wang, L., and W. Chen, "LoRA: Low-Rank Adaptation of
Large Language Models", arXiv arXiv:2106.09685,
Available: https://arxiv.org/abs/2106.09685, October 2021.
[Z3] de Moura, L. and N. Bjorner, "Z3: An Efficient SMT
Solver", Tools and Algorithms for the Construction and
Analysis of Systems (TACAS 2008), LNCS 4963,
DOI https://doi.org/10.1007/978-3-540-78800-3_24, April
2008, <https://doi.org/
https://doi.org/10.1007/978-3-540-78800-3_24>.
[USENIX-ATC-Lumi]
Jacobs, A., Pfitscher, R., Ribeiro, R., Ferreira, R.,
Granville, L., Willinger, W., and S. Rao, "Hey, Lumi!
Using Natural Language for Intent-Based Network
Management", USENIX Annual Technical Conference,
Gu, et al. Expires 6 May 2027 [Page 29]
Internet-Draft Intent Translation and Validation November 2026
Available:
https://www.usenix.org/conference/atc21/presentation/
jacobs, July 2021.
[Survey-IBN-CST-2023]
Leivadeas, A. and M. Falkner, "A Survey on Intent-Based
Networking", IEEE Communications Surveys and Tutorials,
Available: https://ieeexplore.ieee.org/document/9925251,
March 2023.
[Mekrache-IBN]
Mekrache, A., Ksentini, A., and C. Verikoukis, "Intent-
Based Management of Next-Generation Networks: an LLM-
Centric Approach", IEEE Network, Volume 38, Issue 5,
DOI https://doi.org/10.1109/MNET.2024.3420120, September
2024, <https://doi.org/https://doi.org/10.1109/
MNET.2024.3420120>.
[Outlines] Willard, B. and R. Louf, "Efficient Guided Generation for
Large Language Models", arXiv arXiv:2307.09702,
Available: https://arxiv.org/abs/2307.09702, July 2023.
[XGrammar] Dong, Y., Ruan, C., Cai, Y., Lai, R., Xu, Z., Zhao, Y.,
and T. Chen, "XGrammar: Flexible and Efficient Structured
Generation Engine for Large Language Models",
arXiv arXiv:2411.15100,
Available: https://arxiv.org/abs/2411.15100, November
2024.
[GCD] Park, K., Zhou, T., and L. D'Antoni, "Flexible and
Efficient Grammar-Constrained Decoding",
arXiv arXiv:2502.05111,
Available: https://arxiv.org/abs/2502.05111, February
2025.
[JSONSchemaBench]
Geng, S., Cooper, H., Moskal, M., Jenkins, S., Berman, J.,
Ranchin, N., West, R., Horvitz, E., and H. Nori,
"JSONSchemaBench: A Rigorous Benchmark of Structured
Outputs for Language Models", arXiv arXiv:2501.10868,
Available: https://arxiv.org/abs/2501.10868, January 2025.
Gu, et al. Expires 6 May 2027 [Page 30]
Internet-Draft Intent Translation and Validation November 2026
[JSON-Schema-2020-12]
Wright, A., Andrews, H., Hutton, B., and G. Dennis, "JSON
Schema: A Media Type for Describing JSON Documents", Work
in Progress, Internet-Draft, draft-bhutton-json-schema-01,
Available: https://json-schema.org/draft/2020-12/json-
schema-core, June 2022,
<https://datatracker.ietf.org/doc/html/draft-bhutton-json-
schema-01>.
[GSMA-TeleYAML]
GSMA, "GSMA Open-Telco LLM Benchmarks Ranks Frontier AI
Models for Telco AI, Revealing Critical Gap in Network
Automation Readiness", GSMA Newsroom; Open-Telco LLM
Benchmarks 2.0, TeleYAML Intent-to-Configuration task,
Available: https://www.gsma.com/newsroom/article/gsma-
open-telco-llm-benchmarks-ranks-frontier-ai-models-for-
telco-ai-revealing-critical-gap-in-network-automation-
readiness/, November 2025.
[I-D.irtf-nmrg-ibn-usecases]
Yao, K., Chen, D., Jeong, J., Wu, Q., Yang, C., Contreras,
L., and G. Fioccola, "Use Cases and Practices for Intent-
Based Networking", Work in Progress, Internet-Draft,
draft-irtf-nmrg-ibn-usecases-04, 27 October 2026,
<https://datatracker.ietf.org/doc/html/draft-irtf-nmrg-
ibn-usecases-04>.
[I-D.cxxx-nmrg-ai4ibn]
Clemm, A. and T. Eckert, "Agentic AI for Intent-Based
Networking", Work in Progress, Internet-Draft, draft-cxxx-
nmrg-ai4ibn-00, 6 July 2026,
<https://datatracker.ietf.org/doc/html/draft-cxxx-nmrg-
ai4ibn-00>.
[I-D.hong-nmrg-agenticai-ps]
Hong, Y., Youn, J., Wu, Q., and B. Claise, "Motivations
and Problem Statement of Agentic AI for network
management", Work in Progress, Internet-Draft, draft-hong-
nmrg-agenticai-ps-02, 6 July 2026,
<https://datatracker.ietf.org/doc/html/draft-hong-nmrg-
agenticai-ps-02>.
Gu, et al. Expires 6 May 2027 [Page 31]
Internet-Draft Intent Translation and Validation November 2026
[I-D.cgfabk-nmrg-ibn-generative-ai]
Cassara', P., Gotta, A., Fioccola, G., Artigiani, A.,
Burrai, R., Kolaj, E., Martalo', M., and V. Pilloni,
"Generative AI for Intent-Based Networking", Work in
Progress, Internet-Draft, draft-cgfabk-nmrg-ibn-
generative-ai-03, 30 October 2026,
<https://datatracker.ietf.org/doc/html/draft-cgfabk-nmrg-
ibn-generative-ai-03>.
[I-D.cui-nmrg-llm-nm]
Cui, Y., Xing, M., and L. Zhang, "A Framework for LLM
Agent-Assisted Network Management with Human-in-the-Loop",
Work in Progress, Internet-Draft, draft-cui-nmrg-llm-nm-
02, 1 July 2026, <https://datatracker.ietf.org/doc/html/
draft-cui-nmrg-llm-nm-02>.
[I-D.cui-nmrg-llm-benchmark]
Cui, Y., Liu, C., Xie, X., and C. Du, "A Framework to
Evaluate LLM Agents for Network Configuration", Work in
Progress, Internet-Draft, draft-cui-nmrg-llm-benchmark-02,
6 July 2026, <https://datatracker.ietf.org/doc/html/draft-
cui-nmrg-llm-benchmark-02>.
Appendix A. Acknowledgments
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).
Appendix B. Contributors
This document has greatly benefited from inputs and discussions
within the IRTF Network Management Research Group (NMRG), with
contributions from Yong-Geun Hong (Daejeon University) and Joo-Sang
Youn (Dong-Eui University). The authors sincerely appreciate their
contributions.
The following are coauthors of this document:
Gu, et al. Expires 6 May 2027 [Page 32]
Internet-Draft Intent Translation and Validation November 2026
Yoseop Ahn
Department of Computer Science & Engineering
Sungkyunkwan University
2066 Seobu-Ro, Jangan-Gu
Suwon
Gyeonggi-Do
16419
Republic of Korea
Phone: +82 31 299 4106
Email: ahnjs124@skku.edu
URI: http://iotlab.skku.edu/people-Ahn-Yoseop.php
Changes from draft-gu-nmrg-intent-translator-03
The following changes are made from draft-gu-nmrg-intent-translator-
03:
* This version addresses an agentic AI framework and its Intent
Translator. The Intent Translator converts a natural-language
network intent into a structured policy representation, that is,
intent-to-policy translation.
* It reframes the document around detection and mitigation of
structural and semantic errors, including hallucinated policy
content, in the intent-to-policy translation.
* It clarifies the bounded agentic workflow and its 3GPP TS
28.312-based instantiation, including validation outcomes and
targeted recovery.
* It makes scope limitations and evaluation considerations explicit.
Authors' Addresses
Mose Gu (editor)
Department of Computer Science and Engineering
2066 Seobu-Ro, Jangan-Gu
Suwon
Gyeonggi-Do
16419
Republic of Korea
Email: rna0415@skku.edu
URI: http://iotlab.skku.edu/people-Moses-Gu.php
Gu, et al. Expires 6 May 2027 [Page 33]
Internet-Draft Intent Translation and Validation November 2026
Jaehoon Paul Jeong (editor)
Department of Computer Science and Engineering
2066 Seobu-Ro, Jangan-Gu
Suwon
Gyeonggi-Do
16419
Republic of Korea
Phone: +82 31 299 4957
Email: pauljeong@skku.edu
URI: http://iotlab.skku.edu/people-jaehoon-jeong.php
KiHyun Shim
Department of Computer Science and Engineering
2066 Seobu-Ro, Jangan-Gu
Suwon
Gyeonggi-Do
16419
Republic of Korea
Phone: +82 31 299 4106
Email: tlarlguswh@skku.edu
URI: https://iotlab.skku.edu/people-KiHyun_Shim.php
Gu, et al. Expires 6 May 2027 [Page 34]