Portable Semantic Models and Ad Hoc Reconciliation by Cognitive Agents in 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 9 April 2027.¶

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.¶

Table of Contents

1. Introduction

Network management is acquiring participants that reason. Autonomous systems will consume management information, act on it, and exchange it with one another. They will bring machine cognition to a plane whose reasoning and design have, until now, lain with human engineers. The information those systems are handed was shaped for particular programs and the junctions between them, not for stand-alone comprehension by cognitive systems.¶

Two software systems that must exchange information rarely fully share a common model of the world. The classical remedy is a data model agreed in advance. Where that falls short, a richer shared information model or ontology is agreed. Both require broad prior agreement on a common model, one that is negotiated and maintained by people and that can be slow and costly to reach. This document takes up the alternative that opens once the systems on each side can reason for themselves. They can reconcile their divergent models ad hoc, for the occasion, machine to machine, with nothing settled beforehand.¶

The central question is therefore not how to write a better shared data model. It is whether any advance agreement is still required or useful once the participants can reason, and, where it may be, in what form. This document argues, and supports with measurement, that a great deal of what was formerly pre-agreed can instead be produced and reconciled on demand by cognition. What remains worth agreeing is thinner, and more broadly useful, than a full shared model.¶

The account rests on one object and two operations, kept carefully distinct throughout:¶

• the semantic model: the complete, meaning-bearing representation a system's data is lifted into, so that a machine can comprehend it without a human supplying what a schematic form leaves out;¶
• the lift: the cognitive act that produces one semantic model from a system's data; and¶
• reconciliation: the cognitive operation that bridges two independently produced semantic models, so that the systems behind them can interoperate.¶

The semantic model is the output of the lift and the input to reconciliation. The two operations are easily bundled together, yet they are distinct. Completing a single model is needed even for one system in isolation, simply as the price of feeding a cognitive consumer. Reconciling two is needed when two systems must meet. This document treats them separately, then relates them.¶

The contributions are four. First, a self-contained account of the semantic model, the lift, and reconciliation for a network-management audience (Section 3, Section 4, Section 6). Second, a focused treatment of pragmatics, a layer that often carries important operative meaning and is least often discussed (Section 5). Third, a clear separation of the two distinct roles of a thin shared reference (Section 7). Fourth, an empirical study across four network-management scenarios that measures portability, reconciliation without a pre-agreed standard, and where a reference is load-bearing (Section 8). The document closes with the conclusions the evidence supports (Section 9) and their implications for standardization (Section 10).¶

This document stands on its own. Three earlier Internet-Drafts by one of the authors explored these ideas at an earlier and less mature stage (Section 11). They are cited as related work and familiarity with them is not assumed here.¶

2. Terminology and Conventions

This is an Informational research document. It defines no protocol and uses no normative keywords. The following terms are used with the specific meanings given here.¶

Data model

A syntactic and structural artifact, for example a YANG module or a JSON schema, that fixes a form. It carries meaning only implicitly, through the structures it prescribes.¶

Ontology

An explicit account of what a domain admits as entities, attributes, and relationships. It concerns what exists and how things relate, not how any schema expresses these.¶

Lexicon

The set of terms by which an ontology's entities, attributes, and relationships are named. A lexicon is a feature of an ontology, not a separate layer beneath it.¶

Knowledge graph

The ontology together with the individuals that populate it: the typed concepts and permitted relations (the schema, or TBox) and the asserted instances (the data, or ABox). A lifted semantic model contains a knowledge graph, and adds pragmatics and provenance.¶

Pragmatics

How the content is to be used: what a thing is for, whose judgment governs it, whether a figure is a request or a measurement, whether a state is intended or actual, and what a signal means in a given operating context. Pragmatics is the part a schema is least likely to hold. It is treated at length in Section 5.¶

Provenance

The base recording who asserted a given fact, by what method, and how firmly. It runs across all of the above.¶

Semantic model

What a representation needs in order to be complete, in the specific sense that a cognitive system can comprehend it and act on it without a human supplying meaning the form leaves out. Concretely: an ontology, including its lexicon, together with pragmatics, carried over a base of provenance.¶

Lift

The cognitive act of producing a semantic model from a system's data, making explicit the meaning a data model carries only implicitly.¶

Portability

The property of a soundly produced semantic model whereby any sufficiently capable cognitive agent can pick it up and use it, from the package alone, with no pre-agreed standard. Portability is a property of the model, not of any particular downstream task.¶

Reconciliation

The operation of establishing, meaning element by meaning element, how two independently produced semantic models correspond, closing the semantic gaps between them, so that the systems that produced them can interoperate.¶

Reference

A thin, shared, consultable nomenclature (names, disambiguating definitions, and examples) to which a lift or a reconciliation can tie terms and meanings. It is not an ontology or a data schema. Its two distinct roles are the subject of Section 7.¶

False cognate

Two terms that share a label but denote unrelated things. A disciplined reconciliation must refuse such a pairing rather than bind it.¶

Cognitive agent

An autonomous software entity built around a language model together with controlled stores of knowledge, able to reason about what it is given and to communicate in natural language.¶

Comprehension score

The measure of portability used in Section 4: the share of a lifted model's concepts that an independent agent, given only the model package, explains faithfully. Each explanation is graded by meaning, against an authored answer key, as faithful, partial, an honest abstention (the meaning cannot be determined from the package), or invented (a meaning the key does not support). The comprehension score is the fraction judged faithful.¶

Resolved fraction; precision

Two measures of a reconciliation, used throughout Section 8. The resolved fraction is the share of the true correspondences that an agent finds and commits. Precision is the share of what it commits that is correct.¶

3. The Central Object: the Semantic Model

Everything turns on the model a system's data is lifted into. A data model gives form and some of the denotation. What it defers to specification, to convention, and to the engineer's own knowledge are gaps to fill. The semantic model supplies that remainder. It is semantic: it carries meaning, not merely structure. It is ad hoc: built for the case at hand, with no standard model agreed in advance. And it is complete: it carries, as far as possible, the two layers a bare schema generally does not. Those two layers are pragmatics and provenance, and they lie over and above the ontology and its lexicon. The ontology and lexicon fix what the content is about and how its terms are named. Pragmatics governs how the content is to be used. It is the part a schema is least likely to hold, and, as Section 5 shows, often the one that carries important operative meaning. Provenance records who asserted each fact, by what method, and how firmly.¶

 +----------+       +---------------------+
 | System A |-lift->| Semantic model A    |--.
 | data mdl |       | ontology + lexicon, |   \  reconciliation
 +----------+       | pragmatics,         |    \    +-------------+
                    | provenance          |     '-> | Correspond- |
                    +---------------------+     .-> | ence:       |
 +----------+       +---------------------+    /    | aligned     |
 | System B |-lift->| Semantic model B    |--'      | meaning +   |
 | data mdl |       | ontology + lexicon, |         | translators |
 +----------+       | pragmatics,         |         +-------------+
                    | provenance          |
                    +---------------------+

4. Producing the Model: the Lift, and Portability

The lift turns a system's data into a complete semantic model. It is the first thing asked of machine cognition, and it is a cognitive act in its own right, not a schema transformation. It has a bar to clear. A lift is adequate when a sufficiently capable cognitive agent can pick the resulting model up and apply it to any end, from the package alone. A model that clears that bar is portable.¶

How much the lifting agent has to work from depends on how it is situated. An agent embedded within the operational system can interrogate the system for configuration and state, consult whatever documentation and standards are available, and run virtual experiments to observe what a concept does, without altering the running system; so situated, it can always produce a portable lift. Lifting from a static data surface alone, with none of that access, is the stringent floor, and the study examines that floor closely.¶

In lifting, the agent holds a model under construction and works toward the adequacy bar above: at each turn it reads the current state of that model, picks the concept or facet least settled, takes one operation, folds the result back in, and repeats until the model is portable or no affordable operation would improve it. The operations it performs in cognition are the surface reading itself, fixing a concept's kind, its relations, and its meaning from the structure, gloss, synonyms, and examples in front of it. The operations it invokes are the ones an embedded agent has and a surface-only agent does not: interrogating the system for configuration and state, consulting documentation and standards, and running a virtual experiment to observe what a concept does. Each invoked operation returns an observation the agent could not have produced by reading alone, which is why access, not effort, is what separates a portable lift from one stalled at the floor. Figure 2 shows the flow.¶

       The lift: build one portable model from one system
  +-------------------------------------------------------------+
  |  reason: pick the least-settled concept or facet            |<--+
  +-------------------------------------------------------------+   |
                          |                                         |
                          v                                         |
  +-------------------------------------------------------------+   |
  | act                                                         |   |
  |  PERFORM (in the agent's own cognition):                    |   |
  |    read a concept's kind, relations, and meaning from the   |   |
  |    structure, gloss, synonyms, and examples in front of it  |   |
  |  ---------------------------------------------------------  |   |
  |  INVOKE (embedded agent only; an observation returns):      |   |
  |    interrogate the system; consult docs and standards;      |   |
  |    run a virtual experiment on what a concept does          |   |
  +-------------------------------------------------------------+   |
                          |                                         |
                          v                                         |
  +-------------------------------------------------------------+   |
  | observe: fold the result into the model under construction  |---+
  +-------------------------------------------------------------+ repeat
                          |
                          v   (portable, or no affordable step remains)
             a portable semantic model

A semantic model is a set of lifted concepts, each carried under a short header. It helps to see a single such concept in full before measuring what a reader can do with the whole model. The concept below is drawn from the configuration scenario, an ONF Transport API connectivity-service, and it shows the parts a lift makes explicit:¶

{ "id": "t.cs",
  "label": "connectivity-service",
  "synonyms": ["service"],
  "kind": "service",
  "gloss": "an end-to-end connectivity service across the network",
  "example": "the A1-A3 ODU2 service",
  "relations": [ {"rel": "uses",        "target": "t.sip"},
                 {"rel": "realized-by", "target": "t.cep"},
                 {"rel": "over",        "target": "t.topo"} ],
  "instances": ["cs-a1a3-odu2 (ODU2, A1 to A3)"],
  "ref": "connection-service",

  "pragmatics": {
    "use": "the billable, SLA-bearing unit of connectivity",
    "authority": "owned by the service layer; the transport side
                  may not redefine its grade" },

  "provenance": {
    "asserted-by": "the ONF TAPI controller",
    "method": "context export",
    "firmness": "authoritative" } }

Read top to bottom, the concept separates cleanly into the layers of Section 3. The label and synonyms are the lexicon. The kind, relations, and instances are the ontology, and they are exactly the typed schema (the TBox) and the populated data (the ABox) that make up the knowledge graph a lifted model contains. The gloss, example, and ref are supports for a reader rather than model content: the canonical example illustrates the concept for a person and is not one of the instances that populate the ABox. The last two blocks are the ones bare schema normally do not hold. The pragmatics record what the concept is for and whose judgment governs it, so that a consumer knows the service is the billable unit and that the transport side may not redefine its grade. The provenance records who asserted the concept, by what method, and how firmly.¶

 comprehension (meaning score) on the hardest material

 strong |##################################| 1.00
 middle |#############################     | 0.87
 weak   |########################          | 0.73
        +----------------------------------+
        0.0                             1.00

 product
   ^
   |  up: externalises a model;  down: stays internal
   |  +---------------------------+---------------------------+
   |  | Re-documenting from text  | THE LIFT                  |
   |  | un-situated, externalised | situated, externalised    |
   |  | tidier model, still       | writes a self-standing    |
   |  | capped by the text        | model                     |
   |  +---------------------------+---------------------------+
   |  | Un-lifted consumption     | Operating own system      |
   |  | un-situated, internal     | situated, internal        |
   |  | reads the artifact;       | understands in context;   |
   |  | the un-lifted baseline    | no portable artifact      |
   |  +---------------------------+---------------------------+
   +----------------------------------------------------------->
    access: un-situated (artifact only) --> situated (consults system)

5. Pragmatics: Nature, Handling, and Why It Is Often Load-Bearing

Of the parts of a semantic model, pragmatics is the one least talked about. That is probably because it does not freeze cleanly into a schema the way the others do. As it seldom features in schema, it tends to fall out of view and out of consideration. It is, nonetheless, important in operations, and worth setting out plainly. Completing information for a cognitive consumer is, in large measure, capturing the pragmatics a data model leaves out.¶

Where semantics fixes what a term denotes, pragmatics fixes how the denoted thing is to be used. A semantic model records, as first-class content and over and above the ontology and lexicon, matters such as these:¶

• whether a figure is a request to be met or a measurement to be reported, an intent versus an observation;¶
• whose judgment governs a contested field: which side of a boundary owns a route, a grade, or a policy;¶
• the operative state a value describes: whether it is what was intended or what is operationally the case;¶
• the conditions under which a signal changes meaning: an alarm during a maintenance window, or a reading when a detector's confidence is low.¶

Two things about pragmatics emerged clearly from the study. The first is that pragmatics must itself be lifted. It does not as a rule feature in data models, and it is precisely the part a human engineer supplies from outside the artifact. A lift that captures ontology and lexicon but omits pragmatics produces a model that looks complete and is not, and the omission surfaces only when the model must be used to support making operational judgments. The second is that pragmatics is often a highly load-bearing layer. In a range of important operational tasks, signal meaning may be carried as much by pragmatics as by ontology or data structure.¶

Observability is the sharpest case, in the sense of demonstrating both the importance of pragmatics and how it must be handled. The same rising measurement is a matter to act on during normal operation, benign inside a maintenance window, and a matter merely to watch when the detector's confidence is low (Figure 6). None of that is in the value or its type. It is entirely in the pragmatics. The dangerous confusion in this domain is itself a pragmatic one. An alarm, a declared undesirable state, is not an anomaly, a deviation that may mean nothing. Treating them as the same term is a category error that a purely semantic reading does not catch [RFC9940]. The study bears this out with numbers. When the pragmatic content was carried, the strong and middling agents returned the correct significance verdict (accuracy 1.00 and 0.83) and the false-page storm disappeared. When it was withheld, the same agents paged nearly everything (accuracy 0.17 and 0.08). The sound operational verdict could not be judged from structure alone.¶

   signal          context                 verdict
   ------          -------                 -------
               ,-- normal operation -----> act now (page)
   a rising     |
   measurement -+-- maintenance window ---> benign (suppress)
                |
                `-- detector confidence --> watch
                      low

Intent shows the same layer deciding a different kind of question. A declarative expectation, such as a lower bound on capacity, an upper bound on latency, or an availability target, is satisfied by a concrete realization rather than equal to it. Which realisations satisfy it, and how conflicts among expectations are traded off, is pragmatic content, not structural. In the study the pragmatic judgment carried the negotiation. A provider returned a best-achievable offer, and the consumer's own declared priorities accepted a degraded value, with no human in the loop (decision accuracy 1.00 for the strong and middling agents).¶

One further finding sharpens where the payoff sits: how hard a pragmatic judgment is to apply depends on whether it must be made live or has been made in advance. Resolved live, from the operating context, it is an act of judgment, and judgment is capability-gated. Handed the significance context, the weak agent barely moved (accuracy 0.53 with the content, 0.50 without), while the stronger agents reached the right verdict (the 1.00 and 0.83 above). Carried instead as a pre-placed movable policy, a context-to-verdict table the live agent applies by lookup (Figure 7), the judgment has already been made, once, and the live reader need not make it again; the capability gate lifts. Both forms are pragmatics: the policy is the significance judgment pre-decided and written down as structure, while the use and authority of the concept in Figure 3 are the same layer left as prose, to be judged against the live context. The cost of the pre-placed form is not avoided but moved: the judgment is paid for once, in authoring the policy, rather than re-incurred by every reader. So a pragmatic judgment made live is gated by the reader's strength; the same judgment pre-placed as a policy is not.¶

 Pragmatics as a pre-placed policy: a significance judgment, made once,
 applied by lookup rather than judged live

 incoming: a rising measurement + its operating context
                      |
                      v
 the pre-placed policy:
  +-------------------------------+-------------+
  | operating context             | verdict     |
  +-------------------------------+-------------+
  | normal operation, high concern| act (page)  |
  | normal operation, low concern | watch       |
  | maintenance window            | suppress    |
  | detector confidence low       | watch       |
  +-------------------------------+-------------+
                      |
                      v
 verdict read off by lookup: no live judgment, any agent applies it

Because pragmatics is content, it also diverges between two models and must be reconciled like any other layer. Indeed it is one of the principal axes of divergence in Section 6. The practical consequence is a design instruction. A lift that omits pragmatics is not merely incomplete but silently so, and a layer that needs deliberate capture is one a data model is least likely to hold.¶

6. Reconciliation: Bridging Two Models by Cognition

A semantic model is an object, and reconciliation is a flagship use of it. Reconciliation aligns two independently built models, so that the systems that use them natively can interoperate. It is a distinct operation with its own objective, bridging the genuine divergence between two adequate models. That is not a matter of patching bad lifts. Two sound models still diverge, and bridging that divergence is the task.¶

To see the shape of that task, recall what a lifted model contains. It contains a knowledge graph: a schema of typed concepts and permitted relations (the TBox), and the individuals that populate them (the ABox). Over that graph sit the pragmatics and the provenance. Reconciliation must bridge the divergence between two such models wherever it arises: in the ontology, among the instances, and in the pragmatics. These differ in kind, and a treatment that runs them together will miss half the work.¶

Like the lift (Figure 2), reconciliation is also realized as a ReAct-style flow, but a distinct one. Its input is two finished models, not one system's surface, and its product is a set of confirmed correspondences, with aligned meaning and the translators that follow, alongside an honest record of what stays unmatched. Each side runs the loop, and the two are in contact: at each turn an agent reads the state of the alignment so far, chooses the correspondence most in need of settling, takes one operation, folds the result in, and continues until it judges itself at a confident close or its budget is spent. The operations it performs in cognition are the judgments the subsections below set out: proposing a correspondence, refusing a false cognate, deriving a missing concept, and constructing an entry in the shared reference. The operations it invokes are those whose results are the other party's or the system's to give: eliciting the private semantics a bare catalogue does not carry, and running the decisive experiment that separates genuine look-alikes or confirms a refinement. Those observations come back from the counterpart and from the live system. Read this way, the subsections that follow are the action set of this flow: the kinds of divergence it must settle (Section 6.1), the confirmation step (Section 6.2), and the construction of shared ground where none exists (Section 6.3). Figure 8 shows the flow.¶

   Reconciliation: bridge two models (each agent runs this, in contact)
  +-------------------------------------------------------------+
  |  reason: pick the correspondence most in need of settling   |<--+
  +-------------------------------------------------------------+   |
                          |                                         |
                          v                                         |
  +-------------------------------------------------------------+   |
  | act                                                         |   |
  |  PERFORM (in the agent's own cognition):                    |   |
  |    propose a correspondence; refuse a false cognate;        |   |
  |    derive a missing concept; build a shared-reference entry |   |
  |  ---------------------------------------------------------  |   |
  |  INVOKE (the result is the counterpart's or the system's):  |   |
  |    elicit the private semantics a bare catalogue omits;     |   |
  |    run the decisive virtual experiment that separates       |   |
  |    look-alikes or confirms a refinement                     |   |
  +-------------------------------------------------------------+   |
                          |                                         |
                          v                                         |
  +-------------------------------------------------------------+   |
  | observe: fold the reply or result into the alignment        |---+
  +-------------------------------------------------------------+ repeat
                          |
                          v   (confident close, or budget spent)
      confirmed correspondences + translators, with residuals

{
  "id": "ref.crossdomain.adhoc.v1",
  "kind": "lexical",
  "reference_type": "ad_hoc_by_example",
  "note": "Constructed between these two agents for this exchange,
    not adopted from any standard. One entry per shared seam
    category, each fixed by a canonical example. It does NOT cover
    either side's native concepts (grade, bearer, vlan, service);
    that omission pre-empts the cross-domain 'grade' false cognate.",
  "entries": [
    { "id": "transport-underlay",
      "label": "transport underlay",
      "synonyms": ["underlay circuit", "carrier circuit"],
      "class": "seam",
      "definition": "The transport circuit that carries an IP
        service as its underlay: the one object both domains
        share, owned by transport and consumed by IP.",
      "example": "circuit CIR-7 is the underlay of service SVC-42" },
    { "id": "service-rate",
      "label": "committed service rate",
      "synonyms": ["committed rate", "CIR"],
      "class": "requirement",
      "definition": "The committed client payload rate the service
                     guarantees, NOT the bearer line rate.",
      "example": "5 Gbit/s committed (not the bearer line rate)" }
    // + 3 more: demarcation, latency-bound, protection-requirement
  ]
}

 resolved fraction (precision stays 1.00 throughout)

 no shared reference   |######                        | 0.20
 agents build one      |########################      | 0.80
 + one virtual verify  |###########################   | 0.90
                       +------------------------------+
                       0.0                          1.00

      cognition recedes  ------------------------------>

 +------------------+ +------------------+ +------------------+
 | Both cognitive   | | One side inert   | | Cognition in     |
 |                  | |                  | | overlay          |
 | verify: mutual   | | verify: live     | | verify: propose  |
 | Q&A + joint      | | agent runs solo  | | candidates for   |
 | virtual          | | virtual experi-  | | an external check|
 | experiments      | | ments; reference | |                  |
 |                  | | supplies facts   | |                  |
 | reconciliation   | |                  | | no full autonomy;|
 | ALWAYS completes | | mostly completes;| | external         |
 | (autonomous,     | | more is deferred | | adjudication     |
 | verified)        | |                  | |                  |
 +------------------+ +------------------+ +------------------+

7. The Reference, and Its Two Distinct Roles

A shared reference recurs throughout the account, and it earns its place in two separate ways that are easily conflated. Stating them apart is the point of this section.¶

In its first role, a reference supports the lift. Consulted while a model is being produced, it supplies denotation the source surface is too thin to carry, so that a meaning-poor data model can still be lifted into a comprehensible one. This is the repair measured in Section 4, where a reference used in the lift pulled comprehension on a stripped surface back from the 0.64 to 0.74 range up to the 0.79 to 0.85 range. This role serves comprehension generally.¶

In its second role, a reference supports reconciliation. It is the shared common ground two models bind through. Because each side binds its terms to the reference, genuine correspondences arrive as near-identity rather than as candidates to be argued, and false cognates are pre-empted, since two terms that merely share a label bind to different entries. The residual work is confined to what the reference does not cover. This role serves an operation between two parties.¶

These are genuinely separate roles. A careful lift can make a model comprehensible with no reference at all, so the first role may fall away entirely, while the operations that later use the model can still benefit from the second. The practical conclusion is therefore to make the reference, or a pointer to it, part of the model package regardless. It is thin, and may prove useful to downstream operations.¶

Its needed nature follows from both roles and is deliberately minimal, as Figure 9 showed. We find a sound reference to comprise a lexicon with thin supports. For each entry it carries a stable identifier, a preferred name and synonyms, a shallow class, a disambiguating definition, and a single canonical example. That example is explanatory, an aid to a reader, not an instance; the reference holds no ABox of its own. It carries no relationship axioms, cardinalities, or attribute schemas. It is not a model of the domain, and it is emphatically not a universal ontology all parties must accept. In practice it is most often derived from an existing model or standard, and, as Section 6.3 showed, where none exists capable agents can build one. One caution the study makes precise: what binds correctly is the reference's description, never a bare shared pointer. A shared identifier with no description behind it is worse than no reference at all, because an agent may bind by an opaque token - and wrongly.¶

The usefulness of a reference is also graded. It is load-bearing only where there is no standard to lean on and the agent is capable enough to exploit it. Where a public standard already supplies the common ground, a further reference adds little. Where the agent is too weak to reason over the reference, it cannot rescue the outcome. This shows cleanly on the observability ontological cognate: the RFC 9940-anchored reference rescued the middling agent completely, taking it from always conflating the alarm and anomaly concepts to never doing so, while the weak agent conflated the terms with or without it, and the strong agent never needed it. Between those limits the reference does real work, and it does so cheaply: supplying an apt reference cut the cognitive effort a reconciliation spent, measured in reasoning tokens, by a large factor on the harder scenarios, because the agents argued far less.¶

The reference brings a second, independent economy, this one structural. Because each system binds to a shared reference rather than to every other system pairwise, the operational step count associated with reconciliation grows with the number of systems rather than with the number of pairs. N reconciliations to a shared reference replace on the order of N(N-1)/2 pairwise reconciliations. The saving is a matter of counting; what the study checked, out to twelve systems, is that composing the N single-reference bindings reproduces the correct pairwise correspondences, so the linear path is correct and not merely cheaper.¶

8. Evidence from Four Scenarios

The claims above rest on a study run across four network-management scenarios. The scenarios were chosen so that together they span a range of operation classes and the principal ways two models diverge. Each was built, run against a validated gold standard, and reproduced on independently constructed cases. The method is summarised here only as far as is needed to read the results.¶

9. What Holds, and Its Limits

Three conclusions about the concept are supported by the evidence.¶

Semantic-model portability is real, and it is measurably verifiable. A capable cognitive agent understands and uses a soundly produced semantic model from the package alone. This can be checked directly, across a capability ladder and across independent agent families, rather than inferred from a downstream task. Portability is a property of the model, and, as much, of the reader's cognitive capability.¶

Capable cognition reconciles divergent semantic models on its own, with discipline. Where the systems reason well enough, two divergent models are reconciled through the agents' own questioning and virtual verification, with no standard supplied. True correspondences are committed and false cognates refused. At the fully cognitive end of the spectrum reconciliation always completes: an in-principle assertion verified by the study.¶

Portability and reconciliation are graded, not all-or-nothing. Both track the cognition available, degrading gracefully as it recedes rather than collapsing. A thin reference can then partly compensate, rescuing a cognitively weak consumer and making a reconciliation cheaper, though only within the bounds Section 7 describes.¶

The limits are equally real and are stated plainly. Two residues do not yield to cognition, because they are not questions of fact. One is authority. When two sides genuinely conflict over whose value governs a contested field, a reference can supply information but never authority, and the decision stays with a human or an owning party. The study drew this line sharply in the intent scenario: publishing an invariant floor lifted a blind agent's satisfaction check from 0.29 to 0.71, but at both sides inert no reference could move a negotiation whose missing ingredient was the customer's own judgment. The other residue is genuine underdetermination. Where no fact settles a correspondence, an honest agent defers rather than invents one. A reconciliation that reaches these residues and defers is behaving correctly, not failing.¶

And there is the autonomy boundary of Section 6.4. Full, unsupervised reconciliation is available at the fully cognitive end. It is not available where machine cognition is employed only in overlay to two inert systems, which can only propose correspondences for external adjudication. Between those ends the automation degrades predictably, and a thin reference buys back part of what receding cognition gives up.¶

10. Implications for Network Management and Standardization

If portable semantic models can be produced and reconciled on demand by cognitive systems, the question for the community is not whether to abandon standard data models but whether such models should be evolved, and in particular, whether it might be helpful to introduce other standardized artifact types. Our findings suggest an evolution rather than a rupture.¶

What may become most useful to agree in advance may narrow and simplify. As models can increasingly be produced and reconciled ad hoc, for the task at hand, the heaviest fully-specified schemas may give way to lighter, more broadly usable artifacts. Thin shared references, carrying names, definitions, and examples derived from existing models, are the anchor to which independently built systems bind. Such references are relatively easy to maintain and evolve. They are also precisely the kind of interoperable anchor to which emerging knowledge-graph and AI-modeling efforts in the community could bind. The community's knowledge-graph work for network operations [I-D.mackey-nmop-kg-for-netops] meets this approach squarely, since a lifted semantic model contains a knowledge graph a machine can consume, and a thin shared reference is exactly the kind of anchor such graphs can bind to.¶

What still needs agreeing is narrower than a full shared model, and it is of two kinds. The first is the thin references themselves: the small shared anchors reconciliation binds through, worth agreeing precisely because they are cheap and broadly reusable. The second is the authority boundaries the study keeps reaching (Section 9): the contested fields where two systems hold conflicting values and no reasoning can decide whose governs, because the question is one of authority, not of fact. This second kind is not a modeling problem, and better cognition will not dissolve it. Agreeing who governs what is a matter of governance, and it is exactly where standardization remains indispensable, even as ad hoc reconciliation takes over much of the rest.¶

A further implication follows from where the model now comes from. A semantic model is produced by a system's own cognition, the lift, and its form is flexible: what matters is not a fixed schema but that the model carries the elements this document describes, its ontology and lexicon, its pragmatics and its provenance, and explains itself well enough for a capable agent to pick it up. The burden that once fell on a shared model therefore shifts onto a system's ability to describe and interrogate itself. Where a system exposes enough of its structure, its local concepts, its current facts, and its authority and provenance, a consumer's cognition can lift and reconcile against it ad hoc. Where a system exposes none of that, and the meaning is neither in its schema nor available elsewhere, autonomous reconciliation cannot be guaranteed, and the missing content must be drawn from another authoritative artifact, elicited from a live interface, or supplied by a person.¶

This points to a second candidate for standardization, alongside the thin references: not a universal domain model, but a system's self-description and interrogation. What is worth agreeing is how a system exports its structural surface, explains its local concepts, makes its current facts discoverable, declares its authority and provenance, and answers open questions from a consumer that does not know its schema in advance. One architectural pattern that realises this is an interface that declares the concepts and relationships a system supports and assembles the requested knowledge at runtime, rather than fixing all exchanged content at design time, carrying its own provenance and confidence and able to defer where the evidence is insufficient. The point is the capability, not any one serialization or interface: agree how a system explains itself, not the model it uses inside.¶

None of this displaces the installed base. Ad hoc production and reconciliation will coexist with legacy standards and legacy systems, machine to machine, for the task at hand, while the standardization effort is redirected toward the anchors and the authority boundaries that actually need agreeing. The direction is an evolution of where the community spends its modeling effort, not a repudiation of the value that pre-agreement has delivered.¶

11. Related Work

Two earlier Internet-Drafts introduced, at an earlier and less mature stage, ideas this document develops and tests. The first, by one of the present authors, took up agent-to-agent reconciliation of the ontologies implicit in data models [I-D.janz-nmrg-ontology-reconciliation]. The second, by both present authors, introduced thin shared reference lexicons as the anchor for such reconciliation [I-D.janz-nmrg-reference-lexicons]. A third draft, again by one of the present authors, treats the consumer-provider relationship in Network-as-a-Service as a continuous agentic negotiation [I-D.janz-nmrg-naas-agentic-negotiation], the operational setting of the intent scenario here. The present document supersedes the conceptual treatment in those drafts where they differ, and supplies the empirical grounding they lacked.¶

The work sits alongside efforts across the network-management community that share its premise, that operational meaning must be held as structured, machine-consumable knowledge and not as form alone. The community's knowledge-graph framework for network operations [I-D.mackey-nmop-kg-for-netops] proposes exactly the structured, machine-consumable representation this document lifts data into, and the NMOP work on network fault and anomaly terminology and architecture [RFC9940] [I-D.ietf-nmop-network-anomaly-architecture] supplies the vocabulary the observability scenario reconciles against. The network telemetry framework [RFC9232] and the standard topology and traffic-engineering models [RFC8345] [RFC8795] supply further common ground the study draws on. The semantic model, the lift, and the thin shared reference developed here are complementary to all of these. A reference is exactly the interoperable anchor to which such knowledge graphs and modeling interfaces could bind. The theoretical grounding is the classical study of signs [Morris], with the data-to-wisdom lineage [Ackoff] as an alternative framing that arrives at the same structure.¶

12. Open Questions and Next Steps

One important next step is to move the study from purpose-built cases to larger, real, operator-sourced datasets, spanning the same scenarios at production scale and with the messiness of real data. Real models diverge in ways a designed case cannot fully anticipate. The measures reported here, portability, resolved fraction and precision, the reference's graded value, and the cost in reasoning effort, should be re-established on operator data before they are relied upon.¶

A further step is more consequential, and only an operator can take it: to attach cognition to a live operating system and have it perform the lift in place, with real access to state, instances and pragmatics, rather than over a frozen export. This matters more than examining further inert data. An inert dataset, however large, fixes cognition at the un-situated corner of Figure 5: it refines the baseline and re-measures the same surface bound, and it cannot separate a fact the lift could recover from the system from one that is genuinely absent, because past the surface everything looks like one wall. A situated lift makes that separation, and what remains unresolved after a maximally situated lift is the true residue, the authority and underdetermination remainder that bounds automation and that this work defines but does not yet measure.¶

What the experiment involves can be stated concretely. The target is a live management plane with a machine-readable operational view: an ONF TAPI controller, an IETF-YANG datastore reached over NETCONF or RESTCONF under NMDA, a gNMI-served state stream, or a controller such as ONOS or OpenDaylight. The cognition is a capable agent given read-only tools over that plane, datastore reads on the running and operational datastores, topology and inventory reads, a context export where the interface offers one, a telemetry subscription, and a bounded budget of read-only queries it may issue to settle a question, together with its prior over modeling conventions and, optionally, a thin reference. Safety is a first-class constraint: read-only credentials, rate limits, an audit of every call, and no path to a write. Situatedness is a dial the experiment should sweep, from the frozen export alone (the un-lifted baseline), through structural and relational reads, to instances read from the live datastore, to live state, context export and bounded probes, and finally to a self-lift in which the system's own agent authors its meaning.¶

For a chosen slice of the model the agent proceeds concept by concept: it enumerates the concepts from the schema surface; reads each concept's structure, relations and real instances; where the source gloss is thin or absent, generates a grounded gloss from structure, instances and prior and checks it against them; reads the pragmatics, what the thing is for and whose authority governs it, from a context export, from governance or configuration, or, where only a human holds it, by asking; records provenance, marking each fact's method and firmness; and proposes a reference binding. A verifier pass strikes any generation the material does not support, and every fact the agent can neither ground nor read is flagged as a residue candidate for an authority to settle. Portability is then judged exactly as in Section 4.2, but on a model lifted in situ: the lifted model, and only the lifted model, is handed to an independent consumer, and the headline number is the value of the lift, the portability of the lifted model minus the portability of the un-lifted baseline on the same concepts. Crossing the situatedness dial with this measure is the core result: as access climbs, portability should rise and the unresolved set should shrink toward the residue, so that what remains at the top of the dial is the first measurement of the irreducible remainder.¶

Two scenario cases carry the experiment. The first is a configuration seam: a standard-governed model, an ONF TAPI or IETF-YANG view, lifted in situ from a live controller. It is the readiest clean case, where public standards are present, the surface is rich, and portability is the headline a situated lift can establish with least friction. The second is the observability case, and it is the sharper of the two, because the pragmatic layer is decisive there. In the study, the significance verdict, whether a rising measurement is an alarm, a benign maintenance effect, or a low-confidence reading, is recovered only when the pragmatics are present (verdict accuracy 1.00 and 0.83) and collapses when they are stripped (0.17 and 0.08), and the context that fixes significance lives in the running system rather than in any static model. A focused run would attach cognition to an operator's alarm-and-anomaly system, lift its alarm model in situ with the live context, bind it to the shared anomaly-semantics reference, and measure both portability and the pragmatic verdict against the un-lifted baseline. The NMOP work on network anomaly detection and its semantics ([RFC9940] [I-D.ietf-nmop-network-anomaly-architecture]) is already assembling the operational data, the term ladder, and, through its hackathons, the venue such a run would need, and the knowledge-graph representation the data can be held in ([I-D.mackey-nmop-kg-for-netops]) is the form a lifted model naturally takes. The barrier to entry is low, because those inputs and that venue already exist.¶

The authors invite operators and NMRG and NMOP participants to contribute real model pairs and datasets, to attempt situated lifts in these settings, and to help define a shared benchmark over them.¶

Beyond scale, several questions the study opens remain. There is lifting from raw schema text rather than a curated surface, and from a cold start with no instances to read. There is the maintenance of a lifted model and of a shared reference over time. And there is the shape of a published reference ecosystem, and how references derived by different parties from the same standard relate.¶

13. Security Considerations

This document describes a direction and reports experimental findings. It defines no protocol and introduces no new wire format. Nonetheless, several considerations follow from the direction. A semantic model and any accompanying reference become inputs a cognitive agent acts on, and so are targets for manipulation. A poisoned reference, or a lifted model with falsified pragmatics or provenance, could steer a reconciliation to an incorrect but confident result. The provenance layer of a semantic model, who asserted a fact, by what method, and how firmly, is therefore security-relevant and should be integrity-protected, and references should be authenticated to their derivation source. The autonomy boundary of Section 9 is also a safety boundary. Decisions of authority, and correspondences an honest agent defers, must not be silently resolved by an agent acting beyond its competence. This concern is sharpened by a measured finding: agents assert wrong bindings at nearly the confidence of correct ones, so a downstream gate cannot rely on a confidence score alone. Reconciliation outcomes intended to drive operational change should carry the confidence and provenance on which they rest, together with an explicit declaration where evidence was insufficient, so that a supervising system or operator can gate action accordingly.¶

14. IANA Considerations

This document has no IANA actions.¶

Authors' Addresses