Emergent, Dynamic Ontology Generation in Neurocognitive Memory Systems

A deployed architecture in which conceptual structure is grown, tracked, and self-observed rather than declared

5 July 2026

Apple Podcast: https://podcasts.apple.com/us/podcast/deep-dive-frontier-ai-with-dr-jerry-a-smith/id1826091948Soundcloud: https://soundcloud.com/drjerryasmith/emergent-dynamic-ontology

Abstract

Enterprise knowledge systems overwhelmingly rely on hand-authored ontologies: fixed schemas of entity types, relationship types, and domain categories declared up front by knowledge engineers. Ontologies built this way are brittle, because they capture only what the modelers anticipated; static, because they do not evolve as the corpus does; and mute about their own history, because a system that cannot represent how its concepts have changed cannot reason about that change. This paper describes a deployed system that takes the opposite approach. Rather than imposing a schema, it grows one: an ontology emerges from a neurocognitively structured memory substrate, evolves as the underlying corpus does, and — most unusually — is observed by the system itself, which maintains a provenance-grounded, access-controlled record of how its own conceptual structure is changing and why.

The architecture organizes memory as a set of distinct faculties modeled on human memory systems — episodic, semantic, procedural, and reflective — over which unsupervised induction processes propose new entity and relationship types, as well as risk archetypes, from accumulated experience. Every such proposal is governed (a human adjudicates it before adoption), anchored to the documents from which it was derived, and trimmed to each reader's permissions at query time. Above this sits an observability layer that records periodic censuses of the ontology, computes deterministic differences between them, and attributes each change to its causing evidence — a computational analog of metacognitive monitoring of conceptual change.

We report empirical results from a single anonymized enterprise deployment in the private-capital domain, comprising roughly 24,800 entities across six induced types, on the order of 34,000 typed relationships and 180,000 provenance links. Left to run over this substrate, the induction layer autonomously proposed a latent institutional-investor taxonomy, roughly two dozen relationship-type candidates beyond the nine that had been declared, about twenty high-confidence entity-merge corrections, and a quantified leverage-band risk archetype at an intra-cluster coherence of 0.99. The observability layer reconstructed a genuine multi-week population curve from historical timestamps and, applying its diff to that curve, correctly separated structural change — the ontology learning something — from population drift — the corpus merely growing — classifying roughly two-percent-per-week ingestion growth as sub-threshold noise rather than learning. The system is protected by approximately 2,490 automated invariant tests, including an adversarial access-control suite that establishes a subtle but important guarantee: a change concerning an entity a user is not permitted to see is never disclosed to that user, even in the aggregate. We argue that emergent, self-observing ontology is not a convenience but a qualitatively different capability, one that converts a knowledge base from a static map into a living instrument, and we close with value use cases across due diligence, compliance, scientific curation, and intelligence analysis, together with an honest account of the frontier that remains.

1. Introduction

An ontology — a formal specification of the concepts and relationships in a domain [Gruber 1993; Studer et al. 1998] — is the backbone of most enterprise knowledge systems, and in practice it is almost always authored by hand. Knowledge engineers sit down before the system meets its corpus and enumerate the categories and relations they believe it will need. This act of anticipation is the source of three durable and compounding failures. The first is a failure of coverage: the ontology can only ever contain what its authors foresaw, so a category that turns out to matter but was not imagined is simply invisible, and the corpus is quietly forced into a schema that does not fit it. The second is staleness. A corpus grows and shifts continuously as documents arrive and the domain evolves, but a declared ontology does not keep pace; the gap between the map and the territory widens, and nothing in the system registers it. The third failure is the most subtle and, for our purposes, the most important: opacity about change. Even on the rare occasions when a declared ontology is revised, the revision is an undocumented human act. The system has no representation of how its own conceptual structure has changed over time, and therefore cannot answer the question that a maturing understanding most needs to answer — how is what we know different from what we knew before, and what caused the difference?

Inducing schema from text is not a new idea; ontology learning has a long research tradition [Maedche & Staab 2001; Buitelaar et al. 2005; Cimiano 2006], and modern knowledge-graph embedding methods induce relational structure at considerable scale [Bordes et al. 2013; Ji et al. 2021]. But the great majority of this work is aimed at constructing an artifact — building a knowledge graph or a taxonomy that is then treated as more or less fixed. Comparatively little attention has been paid to an ontology that is continuously self-developing, governed rather than merely generated, anchored to its provenance, and — the concern of this paper — capable of observing its own change over time.

The design we present takes its cues from cognitive neuroscience, where memory has been understood for decades not as a single store but as a family of distinct, dissociable systems [Tulving 1972, 1985; Squire 1992]. Episodic memory holds specific events; semantic memory holds the general facts and categories that are abstracted from those events; procedural memory holds skills and routines; and, decisively for us, metamemory and metacognition hold knowledge about one's own knowledge and how it is changing [Flavell 1979; Nelson & Narens 1990]. Two findings from this literature do real architectural work in what follows. The first is that semantic structure is not declared but precipitates from episodic experience through offline consolidation [McClelland, McNaughton & O'Reilly 1995]: categories form gradually during periods of reorganization from an accumulation of specific memories. The second is that conceptual structure is not frozen once acquired; it reorganizes as evidence accumulates [Carey 2009; Chi 1992], and a mature mind can notice that reorganization — it has metacognitive access to its own conceptual change. Our thesis follows directly: if a machine memory is built with these faculties — episodic capture, semantic abstraction through consolidation, and a metacognitive layer that monitors changes in conceptual structure — then an ontology emerges and evolves as a natural consequence of the architecture, rather than being imposed on it from outside.

This paper makes four contributions. It describes an architecture in which entity types, relationship types, and risk archetypes are induced from a neurocognitive memory substrate rather than declared, with every proposal governed and anchored in provenance. It introduces a temporal-metacognition layer that records periodic censuses of the ontology, computes deterministic diffs between them, and attributes each change to its cause — turning on a load-bearing distinction between change to the conceptual map and change to the population it describes. It develops an access-control model for derived, self-referential knowledge, verified by an adversarial test suite, so that even statements about how the ontology itself has changed respect per-user permissions. And it characterizes all of this empirically on a live enterprise deployment, reporting anonymized aggregate results and a set of value use cases, before turning to an honest account of what the system cannot yet do.

2. Background and related work

Three bodies of prior work meet in this system. The first is the study of memory systems in cognitive neuroscience. The multi-store view [Tulving 1972, 1985; Squire 1992] and the complementary-learning-systems account of consolidation [McClelland et al. 1995] supply the template for the substrate: a fast store that captures specific episodes, a slow process that abstracts general structure from them, and a principled separation between the two. The literature on metacognitive monitoring [Flavell 1979; Nelson & Narens 1990] provides the template for the observability layer, and, in particular, for the discipline that the process that monitors the system's knowledge must be kept separate from the process that changes it.

The second is ontology learning and population. Classical methods induce concepts and relations from text using distributional statistics, lexico-syntactic patterns, and clustering [Maedche & Staab 2001; Buitelaar et al. 2005; Cimiano 2006]. Large curated knowledge bases such as CYC [Lenat 1995] and YAGO [Suchanek et al. 2007], and embedding-based approaches to knowledge-graph completion [Bordes et al. 2013; Ji et al. 2021], address the problem at scale. Our work differs from this tradition in three respects that recur throughout the paper: induction here is continuous and governed, producing proposals rather than commits; it is anchored to provenance and access-controlled at the moment of reading; and it is watched over time by a layer whose whole purpose is to answer whether the ontology is changing and why.

The third is the study of conceptual change, where developmental and cognitive science distinguish enrichment — adding instances to a category whose boundaries stay put — from reorganization, in which the boundaries themselves move [Carey 2009; Chi 1992]. This distinction is the direct antecedent of the structural-versus-population-change classes introduced in Section 4, and it is what allows the system to distinguish between learning and mere accumulation. To our knowledge, no previously deployed system brings these three threads together — emergent, governed ontology induction combined with a provenance-grounded, access-controlled, temporal-metacognition layer that answers whether the ontology is changing and why?

3. System architecture

3.1 The neurocognitive substrate

The system is a tiered memory over a document corpus, and its retrieval faculties are deliberately kept distinct, each answering a different kind of question. The episodic faculty answers what happened, holding time-stamped events extracted from documents. The semantic faculty answers what the organization holds to be true, holding facts abstracted from episodes through offline consolidation; each such fact carries a confidence that is not fixed at creation but re-graded every week from its current evidence, so that belief tracks the state of the corpus rather than the moment of assertion. The procedural faculty answers how the organization operates, holding multi-step routines induced from repeated episodic sequences. And the reflective faculty answers what the system itself has previously concluded — a second-order, derived memory that is governed under stricter rules than primary evidence, precisely because it is a claim the system has made about itself. Above these faculties sit a knowledge-graph layer of entities and typed relationships and a quantitative layer of span-grounded numeric observations. The faculties share two physical stores, a vector index and a property graph, but they are never collapsed into one another because they answer genuinely different questions.

Three invariants hold throughout the architecture and are worth stating plainly, because they constrain everything that follows. The source corpus is read-only; the system never writes back to it. No retrieval ever occurs without an access-control check performed first, a rule enforced not by convention but by a meta-test that walks the entire public read surface on every build and fails if any path omits it. And the faculties remain distinct. These are not aspirations but mechanically enforced properties of the codebase.

3.2 The induction layer, where the ontology emerges

Over this substrate run a family of periodic induction processes, and it is here that the ontology emerges rather than being declared. Each induction mirrors the consolidation template — it runs offline, in batch, without supervision — and each attacks a different dimension of the ontology. Entity-type induction clusters the undifferentiated residual bucket of entities that the extractor could not confidently classify and proposes named categories for clusters that are coherent enough to deserve one. Relationship-type induction clusters the last-resort "related-to" edges, the relationships the extractor could not type, and proposes new relation types beyond the declared set, thereby making the relational half of the ontology self-developing as well as the categorical half. Risk-archetype induction clusters span-grounded risk-evidence sentences and propose new, quantified risk categories, thereby expanding the very space of risks that a downstream anticipatory layer can reason about. Entity resolution detects fragmentation — a single real-world entity scattered across several graph nodes — along with extraction junk, and proposes corresponding merges and demotions.

What unifies these processes, and what distinguishes them from ordinary ontology learning, is that each is strictly propose-only and record-only. An induction emits a pending proposal; it never enacts a change. Adoption is a separate human act, and even adoption records a governed decision rather than silently rewriting the underlying data. This is the engineering counterpart to the meta-level and object-level separation in the metacognition literature [Nelson & Narens 1990]: the process that proposes new structure is never permitted to quietly rewrite the structure it observes. Bounding autonomy at the point of proposal is not timidity; it reflects the fact that a wrong-induced type would re-partition everything downstream of it, and a wrong merge would corrupt the graph irreversibly, so both must remain under human authority by construction.

3.3 The observability layer, where dynamics become visible

A separate layer, riding the same weekly consolidation cadence, gives the system awareness of its own conceptual change. It comprises five stages, detailed in the next section: a snapshot census that records the ontology's state, per-element lifecycle metadata, a deterministic diff that compares consecutive states, provenance attribution that explains each change, and a reporting surface that makes all of this legible to a user. Like the induction layer, it is read-only and record-only — the act of observing conceptual change must never itself cause conceptual change, for the same reason a thermometer should not warm the room it measures.

4. Methods

4.1 Governed induction with provenance and empty-basis rejection

Every proposal the induction layer produces carries an evidence basis: the set of source documents from which it was derived. Two rules make that basis load-bearing rather than decorative. The first is candidate-then-check access control. Candidate generation runs under system identity across the whole graph and is therefore permission-agnostic, but nothing ever reaches a human un-trimmed; a proposal is rendered to a reviewer only after its evidence basis has been intersected with that reviewer's live permissions. Under a strict-all policy, an artifact synthesized from a set of documents is visible only to a reader who can access all of them, on the principle that a conclusion drawn from a hundred documents necessarily reveals something about each. The second rule is empty-basis rejection: a content-bearing proposal whose evidence basis is empty is refused at both the write validator and the read surface. This closes a class of vacuous-disclosure bug in which a corrupted proposal with no provenance would pass an access check trivially, because there would be nothing to check it against. Separately, the sampling gates that bound the cost of the language-model calls in each run count attempts rather than successful writes, so that a noisy cluster which repeatedly fails to yield a valid name cannot slip past the budget by never producing an output to count.

4.2 The snapshot census

At each weekly tick the system records an ontology snapshot, an aggregate census of its own conceptual state, and the census is deliberately split into two families of facet that are governed very differently. The structural facets are counts of types — the number of entities of each type, the census of relation, risk, and entity types, the depths of the various proposal queues, and a corpus-wide estimate of entity fragmentation. Because these facets name no individual document, they are pure aggregates and can be read by anyone. The population facets, by contrast, record the connection count and documentary support for a bounded set of watched anchor entities: an operator-curated list, unioned with the automatically included highest-degree entities and with every structural element that has been adopted. Because these facets name specific entities, they are access-controlled at the read surface rather than exposed freely. Snapshots are content-addressed by their tick date, which makes them idempotent, and they reuse an aggregate-report pattern already established elsewhere in the system for weekly usage telemetry.

4.3 The diff, and the distinction between the map and the territory

A deterministic diff, using no language model, compares each snapshot against its predecessor and emits change records, and the single most consequential decision in the entire design is that every change is tagged with a class. A structural change is one in which the conceptual map itself has changed: a new archetype adopted, a new relation type adopted, an entity merge executed. This is the system learning something, and it is the computational analog of conceptual reorganization in the developmental sense [Carey 2009]. A population change is one in which the territory beneath the map has moved: entity counts, or a particular entity's footprint, have grown because documents were ingested. This is the analog of enrichment. The reason the distinction is load-bearing is that conflating the two would be fatal to interpretability. If structural and population change were reported in a single undifferentiated stream, then every answer to the question "why did it change?" would collapse into "because more data arrived," and the one signal that actually matters — the signal that the system has learned something new about its domain — would be buried under the constant churn of ingestion. In practice, structural additions and removals are discretely governed events and are always treated as significant, whereas population shifts are treated as significant only when they clear both a relative-change threshold and an absolute-count floor, so that ordinary week-to-week ingestion jitter is recorded faithfully in the trace but is not mistaken for learning.

4.4 Attribution: the "why" as an access-controlled traversal

Because every atom in the system is linked to its provenance, the cause of any change is a retraceable path rather than an act of introspection, and this matters because human metacognitive attribution is notoriously unreliable — people confabulate reasons for their own conceptual shifts [Nelson & Narens 1990]. Attribution in the current system is deterministic and takes one of three forms depending on the change. For a structural change, the cause is the governed adoption event itself, which is an aggregate, counts-only fact and therefore world-readable — one can say plainly that a new type was adopted on a given date from a given proposal. For a population change that concerns a specific entity, the cause is the set of documents that evidence that entity, intersected with the requesting user's permissions: the change is shown only if the user can read at least one of those documents, the disclosed evidence is trimmed to the subset they are entitled to see, and the remainder is reported to them merely as a withheld count. For an aggregate population change, such as a shift in a total or a per-type count, the cause is a counts-only statement about ingestion drift that names no entity at all. An adversarial test suite verifies the property that makes this safe to expose: a user who cannot read any document that evidences an entity never learns that the entity's footprint has changed. The change is withheld from them entirely, not leaked in summarized form.

4.5 Reconstructing a historical trace

A time series is uninformative at the moment of deployment because a single reading is a fact rather than a trajectory, and the question the observability layer exists to answer is: Is it changing? — cannot be asked of a snapshot, only of a series. Rather than wait weeks for a curve to accumulate, the system reconstructs a partial history from timestamps it already possesses. An entity is known to have existed at a historical tick if its first-seen timestamp precedes that tick, and from this fact alone, the system can rebuild a retroactive entity-population curve. Reconstructed snapshots are explicitly marked as such and are excluded from the live read surface until they have been validated, so that they inform the operator without misleading a user, and any facet that cannot be honestly reconstructed from timestamps — a relation-type census from before those labels existed, say, or a degree measured at a past instant — is flagged as partial, so that a gap in the reconstruction is never read as a real value of zero.

5. Results

All of the results reported here come from a single anonymized enterprise deployment in the private-capital domain and are provided only as aggregate system metrics and domain-generic induced categories. No proprietary entity names, transaction data, or client-specific figures appear.

At the time of measurement, the knowledge substrate held approximately 24,800 entities across six induced entity types — companies, funds, deals, persons, sectors, and an untyped residual bucket — connected by on the order of 34,000 typed relationships and 180,000 provenance links. The system was protected by roughly 2,490 automated invariant tests, among them the access-control meta-test and the adversarial attribution suite described above.

Recommended by LinkedIn

[The Meta-Cognitive Continuum Architecture Pankaj Wahane

10 months ago](https://www.linkedin.com/pulse/meta-cognitive-continuum-architecture-pankaj-wahane-fxykf) [Folddisco and the Hidden Cost of Thinking at the Wrong… Ermelinda Damko

3 months ago](https://www.linkedin.com/pulse/folddisco-hidden-cost-thinking-wrong-resolution-ermelinda-damko-xgd5e) [Phrónēosis | 021 | Engineering Agency in the… Amir Noferesti

2 months ago](https://www.linkedin.com/pulse/phr%C3%B3n%C4%93osis-021-engineering-agency-algorithmic-age-amir-noferesti-lkive)

The clearest demonstration of emergence came from entity-type induction. Run over the undifferentiated residual bucket of roughly four thousand entities the extractor had been unable to type, it autonomously proposed a latent institutional-investor taxonomy — domain-generic categories such as pension fund, endowment, foundation, trust entity, and regulator — none of which had been declared anywhere in the schema. The strongest clusters showed high intra-cluster coherence and were surfaced as governed proposals awaiting human adoption. This is emergence in the strict sense of the word: categories that the modelers had never specified precipitated out of accumulated experience and presented themselves for review.

Relationship-type induction did the same work on the relational half of the ontology. Run over the last-resort reservoir of untyped "related-to" edges, of which there were several thousand, it proposed on the order of two dozen new relationship types beyond the nine that had been declared — again domain-generic relations, such as invested-in, regulated-by, partners-with, contracted-by, and manages — with the largest coherent cluster spanning several hundred edges. This completes what one might call the ontology triad: types and relations both develop themselves, a property that a hand-built ontology cannot have by construction, since both sides of it are fixed the moment they are written down.

Risk-archetype induction produced the result with the most direct downstream consequence. It discovered a quantified leverage-band archetype — a coherent cluster of span-grounded observations describing elevated financial leverage within a specific numeric band — at an intra-cluster coherence of 0.99, grounded verbatim in the source spans from which it was drawn. The significance lies in what it does for anticipation. A downstream anticipatory layer had previously been able to reason only about a small, hand-coded set of risk types; induction expands the very space of risks the system can anticipate, drawing on the organization's own history rather than on an analyst's prior enumeration.

Entity resolution addressed the quality of the substrate on which all of this rests. It surfaced over four hundred fragmented entity groups spanning roughly eight hundred and thirty entities — about three and a half percent of the corpus — in which a single real-world entity was represented as several distinct graph nodes, a pattern typical of multi-shell corporate roll-ups and of spelling and transliteration variants. It proposed on the order of twenty high-confidence merges, using name similarity conjoined with embedding cosine and failing closed whenever an embedding could not be computed, and, conservatively, it proposed no demotions in the sampled run. Because every downstream proposal, base rate, and prediction inherits the quality of the substrate, this correction is a precondition for trustworthy emergence rather than a cosmetic tidying-up.

The observability layer supplied the dynamic results. It wrote a live census and, through backfill, reconstructed a multi-week entity-population curve from historical timestamps, showing genuine corpus growth — an increase of several hundred entities per week over the reconstructed window. When the deterministic diff was applied to this real curve, it did two things correctly and instructively. It tagged the shifts as population change, recognizing that the territory was moving rather than the map. And it classified roughly two-percent-per-week growth as sub-threshold: the growth was recorded faithfully in the trace, but it was not reported as learning. This is precisely the signal-versus-noise discrimination the design intends — the system did not mistake the steady arrival of documents for a change in its understanding. At the first live tick, the read surface honestly reported that there had been no significant structural changes yet, there being only a single live snapshot and no adopted structural events within the window. This is the correct behavior of a metacognitive monitor that does not yet have sufficient trace to speak, not a failure of the monitor.

Finally, the adversarial suite established that the temporal-metacognition surface respects permissions in a way that, to our knowledge, has not previously been required of a system. A population change concerning a specific entity is withheld from any user who cannot read a document evidencing that entity and is disclosed to them only as a count, while structural changes, being counts of types, remain world-readable. The novelty is in the object of the access-control decision: it is applied not to a document but to a statement about how the knowledge base itself has changed.

6. Value use cases

The value of an emergent, self-observing ontology appears most sharply wherever an organization's conceptual structure is both larger than any modeler can pre-specify and changing in ways that carry consequences. Four settings illustrate the range.

Consider first due diligence and transaction analysis. An analyst evaluating a target wants to know not only what the institution already knows about a counterparty, a sector, or a risk pattern, but whether that understanding differs from what it was a quarter ago. Emergent relationship induction surfaces cross-deal patterns — shared advisors, common co-investors, concentrations of supply — that a flat keyword search cannot assemble, as they require joining documents that mention no common term. Entity resolution ensures that the analysis is built on the full record of a counterparty rather than on a single name fragment. And the observability layer flags the moment a newly induced risk archetype, such as a leverage band, begins to recur, which turns a static file into a monitored position. The effect is fewer blind spots, earlier pattern recognition, and an auditable trail of exactly what the institution learned and when it learned it.

Regulatory compliance and change management form a second setting, and here the value follows almost directly from the architecture, because compliance is fundamentally about change: when did a control, an obligation, or a classification shift, and what triggered the shift? A self-observing ontology produces exactly that record — a timestamped, provenance-attributed account of structural change, such as the adoption of a new obligation category on a particular date, derived from a particular set of documents, by a particular reviewer. The structural-versus-population distinction does real work here too, separating genuine reorganization of a controlled vocabulary from the mere accumulation of documents that mention existing terms. The result is defensible, machine-generated change logs and automatic drift detection for the vocabularies a compliance function must keep current.

Scientific and technical literature curation is a third. Research fields continuously reorganize their conceptual structures, spawning new subfields, renaming methods, and merging concepts once thought distinct. A curation system that induces emerging categories from a literature corpus and reports when a new category crystallizes and from which papers gives a research organization a live map of a moving field — including the metacognitive signal that a coherent new cluster has crossed the threshold of critical mass and now warrants a name. The payoff is earlier detection of emerging research fronts and a marked reduction in the ongoing burden of ontology maintenance, which in fast-moving fields is otherwise unrelenting.

The fourth setting is intelligence and investigative analysis, a domain defined, almost by construction, by entity fragmentation — aliases, shell entities, transliterations — and by an acute need to understand what has changed and why, under strict compartmentalization. Emergent entity resolution attacks the fragmentation head-on, unifying an entity across the many forms in which it appears. Provenance attribution answers the question of why a network's structure changed by tracing the evidence rather than making an unsupported assertion. And the access-controlled change surface ensures that even statements about structural change respect need-to-know, so that an analyst cannot learn that an entity they are not cleared to see has grown in importance. The combination — unified entities across aliases, attributable change, and compartment-safe metacognition — is difficult to obtain any other way.

Across all four settings, the differentiator is the same. The ontology is grown rather than declared, so it fits the corpus; it is dynamic, so it tracks the domain as the domain moves; and it is self-observing with provenance, so change is legible and attributable — all of it under read-time access control, which is what makes the whole capability safe to expose to different users with different entitlements. Taken together, these properties convert a knowledge base from a snapshot into a living instrument.

7. Discussion

It is worth being explicit about why the neurocognitive framing does real work rather than serving as decoration applied after the engineering was done. The consolidation template — episodic experience abstracted into semantic structure, offline and periodically — is why categories emerge in this system rather than being declared. The separation of the meta-level from the object-level [Nelson & Narens 1990] is why the observer never silently rewrites the observed. And the distinction between enrichment and reorganization [Carey 2009; Chi 1992] is why the diff must tag every change with a class rather than report a single undifferentiated number. Each cognitive principle maps onto a concrete engineering commitment with a measurable consequence, and removing any one of them would degrade the system in a specific and predictable way.

The governance model deserves a similar defense because it is easy to read the insistence on human adjudication as a limitation on autonomy rather than a feature. Every emergent proposal is adjudicated by a human before it changes anything, and adoption is record-only, registering a governed decision without automatically rewriting existing data. This is deliberate and, we would argue, correct: a wrong-induced type would re-partition everything downstream of it, and a wrong merge would corrupt the graph in ways that are expensive to unwind. Bounding the system's autonomy at the point of proposal keeps emergence safe and auditable while preserving the human's authority over the conceptual structure of their own knowledge, which is precisely where that authority belongs.

The limitations are real and worth stating without hedging. The results characterize a single enterprise corpus, and generalization across domains remains future work. The thresholds that separate signal from noise are configured rather than self-calibrated. Attribution is at present a provenance list rather than a natural-language causal narrative, a choice made deliberately to avoid the confabulation that a generated "why" would risk. Observation is batch, matching the weekly consolidation rhythm, rather than continuous. And there is one limitation that matters more than all the others, which we take some care to state plainly. The system can today observe that its conceptual structure has changed and can attribute the change to its evidence, but it cannot yet validate that a discovered structural change improved the organization's predictions, because such validation requires realized-outcome history — a record of how past situations actually resolved — which the corpus does not yet contain. Closing this loop, by linking induced structure to realized outcomes, is the single highest-leverage extension available to the system, and it is the precondition for turning descriptive metacognition, which can say that the ontology changed, into evaluative metacognition, which could say that the change made the organization more right.

Seen from a distance, the trajectory is deliberate and cumulative. The system moves from memory, which records experience, to emergence, which induces structure from that experience, to metacognition, which observes the structure changing, and next toward validation, which would grade whether a given change actually helped. Each stage is a strictly harder form of self-knowledge than the one before it, and each is gated by the substrate that the previous stage produced.

8. Conclusion

We have described and empirically characterized a deployed system in which an ontology is not declared but emerges from a neurocognitively structured memory substrate, evolves as the corpus does, and is observed by the system itself, with every change anchored to its provenance and controlled by per-user access rights — even when the knowledge in question is a statement about the knowledge base's own change. In a real enterprise deployment, unsupervised induction proposed a latent investor taxonomy, a relationship taxonomy beyond the declared set, a quantified risk archetype, and a substrate-quality correction spanning roughly three and a half percent of the corpus, while the observability layer reconstructed a genuine population curve and correctly distinguished learning from noise. What results is a knowledge system that can answer not merely what we know, but how our understanding is changing, and why — the apex question of a self-developing ontology, and one that a hand-authored ontology can never ask of itself.

References

Bordes, A., Usunier, N., Garcia-Durán, A., Weston, J., & Yakhnenko, O. (2013). Translating embeddings for modeling multi-relational data. Advances in Neural Information Processing Systems (NeurIPS) 26.

Buitelaar, P., Cimiano, P., & Magnini, B. (Eds.) (2005). Ontology Learning from Text: Methods, Evaluation and Applications. IOS Press.

Carey, S. (2009). The Origin of Concepts. Oxford University Press.

Chi, M. T. H. (1992). Conceptual change within and across ontological categories. In R. Giere (Ed.), Cognitive Models of Science. University of Minnesota Press.

Cimiano, P. (2006). Ontology Learning and Population from Text: Algorithms, Evaluation and Applications. Springer.

Flavell, J. H. (1979). Metacognition and cognitive monitoring: A new area of cognitive–developmental inquiry. American Psychologist 34(10): 906–911.

Gruber, T. R. (1993). A translation approach to portable ontology specifications. Knowledge Acquisition 5(2): 199–220.

Ji, S., Pan, S., Cambria, E., Marttinen, P., & Yu, P. S. (2021). A survey on knowledge graphs: Representation, acquisition, and applications. IEEE Transactions on Neural Networks and Learning Systems 33(2): 494–514.

Lenat, D. B. (1995). CYC: A large-scale investment in knowledge infrastructure. Communications of the ACM 38(11): 33–38.

Maedche, A., & Staab, S. (2001). Ontology learning for the Semantic Web. IEEE Intelligent Systems 16(2): 72–79.

McClelland, J. L., McNaughton, B. L., & O'Reilly, R. C. (1995). Why there are complementary learning systems in the hippocampus and neocortex: Insights from the successes and failures of connectionist models of learning and memory. Psychological Review 102(3): 419–457.

Nelson, T. O., & Narens, L. (1990). Metamemory: A theoretical framework and new findings. The Psychology of Learning and Motivation 26: 125–173.

Squire, L. R. (1992). Memory and the hippocampus: A synthesis from findings with rats, monkeys, and humans. Psychological Review 99(2): 195–231.

Studer, R., Benjamins, V. R., & Fensel, D. (1998). Knowledge engineering: Principles and methods. Data & Knowledge Engineering 25(1–2): 161–197.

Suchanek, F. M., Kasneci, G., & Weikum, G. (2007). YAGO: A core of semantic knowledge. Proceedings of the 16th International Conference on World Wide Web (WWW): 697–706.

Tulving, E. (1972). Episodic and semantic memory. In E. Tulving & W. Donaldson (Eds.), Organization of Memory. Academic Press.

Tulving, E. (1985). How many memory systems are there? American Psychologist 40(4): 385–398.

Author's note on data disclosure: all quantitative results are reported in aggregate, anonymized form. No corpus content, entity names, transaction data, or client-identifying information appears in this paper. Induced categories named herein — pension fund, invested-in, leverage band, and the like — are domain-generic taxonomic terms, not proprietary designations.