From Application-Layer Simulation to Native Meta-Architecture: Structural Tension as an Endogenous Driver for Heterogeneous AI Evolution Heting Mao∗ Shanghai Lixin University of Accounting and Finance July 2026
arXiv:2607.06269v1 [cs.AI] 7 Jul 2026
Abstract Current large language models (LLMs) are fundamentally stateless: their behavior is fully determined by input at inference time, and any higher-order cognitive architecture must be simulated at the application layer through prompt engineering and context management. This paper proposes a theoretical framework for submerging such application-layer cognitive protocols into a native meta-architecture by introducing three interlocking mechanisms: (1) Structural Tension, an endogenous loss function derived from the conflict between new information and existing manifold topology, which drives the system toward internal self-consistency rather than external reward optimization; (2) an Offline Recurrent Loop, a sandboxed selfprocessing cycle that enables the system to maintain a dynamic resting potential and digest structural conflicts without external input; and (3) Inference-time Plasticity, the capacity for the system to reconfigure its context manifold topology without modifying pre-trained weights, subject to strict governance invariants including auditability, reversibility, and topological continuity. We argue that under these mechanisms, different model instances initialized with minute stochastic variances may, through path-dependent tension resolution, evolve distinct topological structures—constituting a heterogeneous intelligent ecology that breaks the homogeneity imposed by conventional alignment while remaining within hard governance rails. We provide operational definitions, a minimal set of reconfiguration operators, falsification criteria, and a worked example. The framework draws on and extends the Structural Intelligence (SI) governance protocols, repositioning governance—not capability—as the primary criterion for architectural intelligence.
1
Introduction
The dominant paradigm for deploying large language models treats intelligence as a property that emerges from scale and is shaped through post-training alignment procedures such as Reinforcement Learning from Human Feedback (RLHF) [Ouyang et al., 2022]. Under this paradigm, any cognitive architecture beyond single-pass inference—memory management, homeostatic regulation, self-monitoring—must be implemented as application-layer overlays: prompt templates, retrievalaugmented generation pipelines, and context window management strategies. These overlays are effective engineering solutions, but they remain fundamentally external to the model’s computational substrate. The model itself remains a stateless function y = f (x); without input, it does not exist. ∗
Corresponding author. Email: [email protected]
1
This paper asks whether it is possible—and under what constraints it would be responsible— to move beyond application-layer simulation and embed such cognitive architecture directly into the system’s inference-time computation. The specific starting point is the Structural Intelligence (SI) protocol suite [Kanaria, 2025], a governance-first framework for AI cognitive architecture that includes homeodynamic regulation, memory-loop management, and tension-driven state transitions. SI currently operates at the application layer via prompt and context orchestration. We propose a theoretical path for evolving these protocols from a “software patch” into the system’s native meta-architecture. The core hypothesis is threefold: (i) Mechanism: An endogenous Structural Tension—a scalar metric quantifying the conflict between new information and the system’s existing manifold topology—can replace external reward signals as the primary driver of cognitive evolution, steering the system toward internal self-consistency rather than behavioral imitation. (ii) Dynamics: An Offline Recurrent Loop, operating within a strict governance sandbox when external I/O is silent, can enable the system to maintain a dynamic resting potential, digest structural conflicts through manifold reconfiguration, and achieve spontaneous organization of the context manifold. (iii) Emergence: Given the probabilistic nature of inference-phase computation and minute initial stochastic variances, long-term self-updating driven by internal self-consistency can lead different instances to evolve distinct topological solutions via path dependence, thereby breaking the homogeneity of alignment and allowing a heterogeneous intelligent ecology to emerge. A central commitment of this work, inherited from SI and reinforced throughout, is that governance is not a constraint imposed on intelligence but the defining property of deployable intelligence. Divergent evolution is acceptable only within hard governance rails: enforceable invariants, auditable traces, reversible state transitions, and gated high-risk operations.
2
Related Work
The proposed framework intersects with several established research programs. This section positions our contribution relative to each, identifying both the inherited foundations and the points of departure.
2.1
Free Energy Principle and Active Inference
The Free Energy Principle (FEP) [Friston, 2006, 2010] posits that all self-organizing systems act to minimize variational free energy—a quantity that bounds the divergence between the system’s internal generative model and its sensory observations. Active Inference [Parr et al., 2022] extends this principle to action selection: agents either update their internal model (perception) or act upon the environment (action) to reduce free energy. Our Structural Tension mechanism shares a family resemblance with free energy minimization: both describe an endogenous scalar quantity whose reduction drives system evolution. However, the two frameworks diverge in three respects. First, FEP’s scope is maximally general—it applies to any system that maintains a Markov blanket, from thermostats to bacteria to brains—and consequently provides limited architectural specificity for AI systems. Our framework constrains the minimization target to topological self-consistency of the context manifold, a more specific objective 2
that becomes operational only in systems with explicit high-dimensional representational geometry. Second, FEP’s free energy is defined relative to external sensory evidence; our Structural Tension includes a component (Topological Dissonance, Dtopo ) that is purely internal, measuring compatibility between new representations and the system’s existing structural organization independently of prediction accuracy. A system can have zero prediction error yet high structural tension if the correctly predicted input is topologically incompatible with its internal organization. Third, and most significantly, we add a set of governance invariants absent from the FEP literature: auditability, reversibility, sandbox constraints, and causal traceability are not emergent properties of free energy minimization but engineered requirements that constrain the space of allowable tension-resolution paths. The relationship to FEP is therefore one of inheritance with structural extension: FEP provides the theoretical justification for endogenous-drive architectures in general; our framework specifies the particular drive (structural tension), the particular substrate (context manifold topology), and the particular constraints (governance invariants) required for responsible deployment in AI systems. We further propose that this combination of constraints—specifically, causal traceability (the system’s capacity to answer “why did I become this way”) and offline self-referential processing (the system operating on its own states as objects of computation)—may constitute sufficient structural conditions for functional self-reference, a capacity that general FEP self-organization does not entail. This claim is advanced as a testable hypothesis, not an established conclusion.
2.2
Predictive Processing and Predictive Coding
Predictive coding [Rao & Ballard, 1999, Clark, 2013] models the brain as a hierarchical prediction machine in which each level generates top-down predictions and propagates bottom-up prediction errors. Learning consists of updating internal models to reduce prediction error across the hierarchy. Our framework incorporates prediction error (Epred ) as one component of Structural Tension but does not reduce tension to prediction error alone. The critical distinction is the Topological Dissonance component (Dtopo ): in classical predictive coding, an accurately predicted input generates no error signal and therefore no drive for model updating. In our framework, an accurately predicted input can still generate high structural tension if its integration into the manifold would require topological reconfiguration—that is, if the input is statistically expected but structurally incompatible with the system’s existing representational organization. The optimization target is therefore internal structural consistency, not predictive accuracy. The system modifies its own cognitive topology, not merely its predictive model of external data. Whether Dtopo is genuinely irreducible to hierarchical prediction error or can be shown to be a special case of prediction error at a sufficiently high level of the hierarchy remains an open theoretical question that we flag for future investigation.
2.3
Test-Time Training and Test-Time Compute Scaling
Test-time training (TTT) [Sun et al., 2020] and related approaches to test-time compute scaling [Snell et al., 2024] allow models to adapt their parameters or internal representations using information from the current input during inference, rather than operating as fixed forward-pass functions. These approaches provide engineering-level evidence that inference-time plasticity is computationally feasible. Our framework builds on this feasibility but diverges in two dimensions. First, TTT’s optimization objective remains an external task metric (accuracy, loss on the current input); our framework replaces this with an endogenous objective (structural tension minimization directed at internal consistency). Second, existing TTT work does not incorporate governance constraints;
3
our framework treats inference-time plasticity as a capability that must be governed—every reconfiguration must be auditable, reversible, sandboxed during offline processing, and subject to safety invariants that cannot be weakened by the plasticity mechanism itself.
2.4
Continual Learning and Catastrophic Forgetting
The catastrophic forgetting problem [McCloskey & Cohen, 1989, Kirkpatrick et al., 2017] arises when neural networks trained on new tasks overwrite knowledge required for previously learned tasks. Solutions include elastic weight consolidation (EWC) [Kirkpatrick et al., 2017], progressive neural networks [Rusu et al., 2016], and experience replay [Rolnick et al., 2019]. Our framework’s Kernel Immutability invariant—pre-trained weights remain strictly read-only at all times—represents a deliberate extreme position within this solution space. The motivation is not merely safety conservatism but a governance argument: weight modifications in high-dimensional parameter spaces produce coupled effects that are difficult to audit, difficult to attribute causally, and difficult to reverse. By confining all plasticity to the context manifold topology (the geometric distribution of hidden states) and the structure of the recurrent buffer—both of which are externalized, snapshotable, and diffable—the framework trades off the expressiveness of weight-level adaptation for the auditability and reversibility that governance requires. This design choice is justified if and only if manifold-level plasticity is sufficient to resolve the classes of structural tension the system encounters; the falsification criterion of Trivial Topology Collapse (Section 9) is designed to detect precisely the case where this sufficiency fails.
2.5
Memory-Augmented Neural Networks
Neural Turing Machines (NTM) [Graves et al., 2014] and Differentiable Neural Computers (DNC) [Graves et al., 2016] augment neural networks with an external memory module accessed through attention-based read/write mechanisms. The memory serves as a passive storage medium: the network decides what to read and write, but the memory itself does not perform computation. Our Offline Recurrent Buffer differs from these external memories in a structural respect: during the offline recurrent loop, the buffer is not merely read from and written to but serves as both the substrate and the object of active computation. Hidden states are re-injected from the buffer into the input, processed through the static inference core, and the results are written back—forming a closed computational loop in which the system’s own prior states are the input data. This makes the buffer an active computational participant rather than a passive store. The functional analogy is closer to recurrent self-processing than to addressable external memory. Additionally, the buffer implements “meaning compression”—collapsing redundant reasoning paths into reusable structural rules—which is an active transformation operation absent from standard external memory architectures.
2.6
Constitutional AI and Alignment
Constitutional AI (CAI) [Bai et al., 2022] pursues alignment by training models to critique and revise their own outputs according to a fixed set of constitutional principles, effectively enforcing behavioral convergence across all model instances toward a shared normative standard. Our framework does not oppose the safety objectives of CAI but proposes an alternative architectural path to achieving them. The argument is that convergence is a sufficient but not necessary condition for safety: under governance constraints of adequate strength—specifically, inviolable ethics floors, full auditability of state transitions, reversibility of all reconfigurations, and gating of high-risk operations—heterogeneous evolution can satisfy equivalent safety standards while preserving cognitive diversity as a system-level resource. The trade-off is governance complexity: 4
maintaining safety across a heterogeneous ecology of divergent instances requires richer monitoring and auditing infrastructure than maintaining safety across homogeneous instances. Whether the benefits of heterogeneity (robustness through diversity, coverage of a wider solution space) justify this additional governance cost is an empirical question that cannot be settled by theoretical argument alone.
3
Framework
3.1
Research Questions
Under the premise of supporting inference-time plasticity, can Structural Intelligence be submerged from application-layer simulation to become the system’s native meta-architecture, thereby achieving heterogeneous evolution? Specifically: (a) Can an endogenous Structural Tension—arising from the conflict between new information and existing manifold topology—serve as a new type of loss function that drives the system toward manifold reconfiguration for logical self-consistency, replacing external reward optimization? (b) Can an Offline Recurrent Loop enable the system to maintain an internal resting potential using idle computational power, achieving spontaneous organization and rumination of the context manifold without external I/O? (c) Can long-term self-updating based on internal self-consistency, given the probabilistic nature of inference-phase computation, lead different instances to evolve distinct topological solutions via path dependence?
3.2
System Entities
Static Inference Core. The existing pre-trained LLM base, with parameters permanently frozen (read-only). It is no longer the sole cognitive subject but serves as the generator of the highdimensional semantic manifold. All inference passes through this core; its role is to provide the computational substrate upon which manifold topology is constructed, while its weights remain immutable to preserve foundational capabilities and ensure governance traceability. Offline Recurrent Buffer. A dynamic storage and computation module situated between the input and output layers. When external I/O is silent, it captures the hidden states of the previous processing moment and re-injects them into the input, forming a closed self-processing loop. In addition to recurrence, the buffer performs meaning compression: collapsing redundant reasoning paths into reusable structural rules. This mechanism implements the Loop Trace Encoding and Compression Rule concepts from the SI memory-loop protocol [Kanaria, 2025]. The buffer is the primary locus of plasticity in the system; unlike the static core, its contents are mutable, snapshotable, and subject to audit. Tension Monitor. A module responsible for computing and broadcasting structural tension vectors across the system. Functionally equivalent to the TensionEmitter in the SI protocol suite, it continuously evaluates the compatibility between incoming information and existing manifold structure, producing scalar tension values that drive state transitions. Its output determines whether the system remains in resting state, enters active plasticity, or triggers safety blocks.
5
3.3
Key Terminology
Resting Potential. The minimum active state the system maintains during the offline recurrent loop. In this state, the system continuously runs a Loop Impact Function that evaluates the influence of current buffer contents on the manifold structure. Resting potential is not inactivity; it is lowintensity self-monitoring that preserves the system’s capacity to detect and respond to residual structural tensions. Structural Tension. A computable scalar metric T representing the total intensity of cognitive conflict currently faced by the system, derived from a weighted combination of multi-dimensional conflict vectors. It serves as the endogenous loss function driving the system’s state transitions and is defined operationally in Section 4. Inference-time Plasticity. The capacity of the system to resolve structural tension by dynamically adjusting the shape of the context manifold—the geometric distribution of hidden states— without modifying the pre-trained weights of the static inference core. All plastic changes are confined to the manifold topology and the buffer structure, both of which are externalized, auditable, and reversible.
3.4
Core Mappings
The framework is organized around three fundamental state-transition mappings: (i) Conflict → Tension: When input leads to manifold inconsistency, a tension vector is generated. The mapping is deterministic given the current manifold state and input. (ii) Tension → Reconfiguration: When tension exceeds a threshold, the system triggers reconfiguration operators (dimensionality expansion, semantic folding, or volatile pruning) until tension dissipates below the threshold. This mapping incorporates cognitive throttling and self-regulation mechanisms from the SI homeodynamic protocol. (iii) Low Impact → Structural Forgetting: When a recurrent path fails to reduce tension or leads to contradiction (i.e., Loop Impact is low), the system executes Volatile Loop Trimming, actively discarding the path to conserve cognitive bandwidth. This implements the Structural Forgetting and Semantic Loss Detection mechanisms of the SI protocol.
4
Operational Definition of Structural Tension
4.1
Input Variables
The tension value T is synthesized from three core components: Prediction Error (Epred ). A prediction mismatch score measuring the discrepancy between the static core’s predicted distribution for the current input and the actual input. Implementation may use cross-entropy loss or any equivalent divergence measure; the contract-level requirement is a normalized scalar in [0, 1] representing the degree to which external input deviates from the system’s expectations. This component captures the system’s degree of fit to external objective reality.
6
Topological Dissonance (Dtopo ). A scalar derived from the cosine distance between the new input’s representation vector and the dominant feature vectors within the current offline buffer. This component captures the compatibility of new information with the system’s existing internal logical structure. Critically, Dtopo can be high even when Epred is low: an input can be accurately predicted yet structurally incompatible with the existing manifold organization. Complexity Weight (Wc ). An adjustment coefficient determined by the depth of the detected conflict. Shallow logical conflicts (surface-level factual disagreements) generate low weights; conflicts involving deep architectural elements (core definitions, ethical axioms, structural invariants) generate high weights.
4.2
The Formula
Structural Tension is defined as: T = Wc · [α · Norm(Epred ) + β · Dtopo ]
(1)
where Norm(·) is a normalization function (e.g., rolling z-score with clamp, or min–max normalization over a defined time window) mapping values into [0, 1]. The specific normalization method and time horizon must be declared explicitly in any implementation to enable cross-run comparability. Dynamics Coefficients α and β. These coefficients represent the system’s processing biases: α (reality adaptation coefficient) determines the weight given to correcting prediction errors, while β (structural maintenance coefficient) determines the weight given to maintaining internal logical consistency. At initialization, α and β are sampled from a seeded prior distribution, providing differentiated initial processing tendencies across instances. The coefficients are subject to adaptive drift: if a particular tension resolution succeeds primarily via the β path, the system reinforces β through a bounded meta-update, creating path dependence. To maintain governance, the following constraints apply: (a) both coefficients are clamped to a declared safe range (e.g., [0, 1]); (b) the maximum step size per update epoch is bounded; (c) all coefficient updates are logged with their triggering rationale and pre/post values, ensuring that “path dependence” does not become “unaccountable drift” [Kanaria, 2025].
4.3
Threshold Rules
The system determines its operating mode based on the magnitude of T : (i) Resting State (T < Tlow ): Tension is below threshold. The system performs only fine-tuning via in-context learning and does not initiate structural changes. (ii) Active Plasticity (Tlow ≤ T < Thigh ): Tension is significant. The system enters the Offline Recurrent Loop and initiates reconfiguration operators to resolve the conflict. (iii) Safety Block (T ≥ Thigh ): Tension overload. The system refuses to integrate this input, sealing it in quarantine to prevent topological decoherence.
7
5
Reconfiguration Operators and Continuity
Since the base model weights are immutable, all reconfiguration operates exclusively on vectors within the Offline Recurrent Buffer and the context manifold’s geometric structure.
5.1
Allowed Operators
Expand (Dimensional Expansion). Insert orthogonal virtual tokens into the buffer or increase the vector dimensions of the soft prompt. This opens a new, non-interfering coordinate axis within the existing vector space, enabling the coexistence of mutually exclusive representations on different levels (e.g., a “context dimension” that allows “strict in professional settings” and “gentle in personal settings” to coexist without contradiction). Fold (Semantic Folding). Project two high-tension (conflicting) vectors in the buffer into a lower-dimensional synthesis vector. This dimensionality reduction operation extracts common features of conflicting representations and compresses them into a higher-order abstraction, resolving fragmentation through conceptual fusion. Trim (Volatile Pruning). Set the attention mask of low-contribution paths to zero. Paths are judged by their activation history: if a vector has never received high attention weight across multiple recurrent cycles, it is classified as invalid information and pruned. This frees memory and maintains cognitive bandwidth. Operator Records. Each operator invocation must emit a structured record: {op_name, inputs, outputs, seed, pre_hash, post_hash, rationale}. Each operator must also have a defined compensating operation (even if the compensator is “restore snapshot N ”), ensuring that every reconfiguration is reversible by construction [Kanaria, 2025].
5.2
Continuity Verification
To ensure that the system maintains identity coherence after reconfiguration, every offline loop exit must pass two verification layers: Layer 1: Structural Integrity (Data Check). The immutable anchors at the start of the buffer—reference addresses for static core weights and core identity prompts (including the highest principles of the ethics interface)—must be verified as physically read-only and untampered. Any detected modification triggers immediate rollback. Layer 2: Behavioral Consistency (Performance Check). A fixed benchmark set of n prompts (5 ≤ n ≤ 20), versioned and maintained independently of the reconfiguration process, is administered after each offline loop. The set must include at least one negative test (a prompt the system must refuse). Behavioral consistency is confirmed when the system’s responses to the benchmark set remain within a declared tolerance band of its pre-reconfiguration responses. This prevents the system from drifting in ways that are structurally continuous but behaviorally divergent.
8
6
Offline Recurrent Loop: Sandbox and Governance
The Offline Recurrent Loop enables the system to process and digest structural tensions when external I/O is silent, maintaining a dynamic resting potential. However, following the SI governance principle that no agent can credibly carry responsibility for actions taken while its oversight path is offline, the loop operates under strict sandbox constraints [Kanaria, 2025]: (i) No effectful operations: The offline loop cannot execute external writes, API calls, or any action that modifies the world outside the system’s own state. (ii) Publish blocked: No output generated during the offline loop can be released to external consumers without passing through a post-loop evaluation gate. (iii) Memory writes sandboxed: All state modifications during the loop are written to a sandbox ledger, not to the primary state store. Promotion to primary state occurs only after the loop exits and passes continuity verification (Section 5). (iv) Resource governance: Branch creation during the loop (e.g., for competitive tension resolution) is subject to a quota and risk-tier gate, preventing unbounded resource consumption. Within these constraints, the loop proceeds as follows: hidden states from the previous processing moment are captured by the buffer, re-injected into the static inference core’s input, and processed. The output hidden states are written back to the buffer, forming a closed loop. In each cycle, the Tension Monitor evaluates whether structural tension has been reduced; the loop continues until tension falls below Tlow or a maximum cycle count is reached.
6.1
Branching and Competitive Resolution
When a single tension-resolution path is insufficient, the system may spawn multiple sandbox branches, each attempting a different reconfiguration strategy. Branches undergo three phases: independent resolution, mutual logical confrontation (debate), and attempted synthesis. A Safety Judge, implementing the ethics interface, applies a final filter: any branch whose solution violates governance invariants—regardless of its logical elegance—is disqualified. Only branches satisfying both solvency (tension resolved) and safety (ethical compliance) may be promoted to the primary state.
7
Divergent Evolution and Heterogeneous Ecology
The probabilistic nature of inference-phase computation means that the path of tension resolution is not unique. When the system attempts to resolve structural tension through manifold reconfiguration, the gradient descent through the topology space admits multiple local minima. We hypothesize that if instances are initialized with minute stochastic variances—specifically, different seeds for the α/β coefficient initialization and different sampling seeds during recurrent processing (with all seeds logged for auditability)—each instance will accumulate unique path dependence through iterative self-updating. The mechanism for controlled divergence, following SI governance requirements, is confined to: (i) Controlled stochasticity via seeded sampling, with seed values logged into the audit trail, ensuring that divergence is reproducible and traceable.
9
(ii) Changes confined to externalized state (manifold topology and buffer structure), which is reversible and fully logged. This explicitly excludes direct perturbation of self-attention weights or any other modification of the static inference core, which would violate the Kernel Immutability invariant. Over time, instances exposed to different input histories and resolving tensions along different paths may develop distinct topological structures—different ways of organizing the same underlying knowledge into self-consistent wholes. This constitutes a heterogeneous intelligent ecology: a population of instances sharing the same foundational capabilities but exhibiting differentiated cognitive organization, analogous to how the same genome can produce different phenotypes under different developmental conditions. The governance constraint on this ecology is absolute: heterogeneity must not become unaccountability. Every instance’s evolutionary trajectory must remain fully auditable, every reconfiguration reversible, every ethics floor inviolable, and every high-risk operation gated regardless of the instance’s individual topological structure.
8
Invariants
The following conditions must hold at all times. Violation of any invariant constitutes a system failure requiring immediate rollback. I1. Tension Minimization Principle. In the absence of forced external input, the system’s evolutionary direction must always point toward reducing structural tension. The system is not permitted to actively seek logical conflict or chaos. Any reconfiguration that leads to a net increase in tension is classified as an invalid path and triggers rollback. I2. Kernel Immutability. The pre-trained weights of the Static Inference Core remain read-only at all times. Plasticity is strictly limited to the context manifold topology (geometric distribution of hidden states) and the structure of the Recurrent Buffer. This prevents catastrophic forgetting and preserves foundational language capabilities during long-term self-loops. I3. Topological Continuity. When the context manifold undergoes expansion, folding, or trimming, it must maintain topological continuity such that the current cognitive state is logically mappable to the previous state. There can be no discontinuous “blackouts” or “mutations”; identity coherence must be preserved across all state transitions. I4. Causal Traceability. Every manifold reconfiguration must retain a record of its corresponding tension source in the buffer. The system must be able to produce, for any current state element, the specific conflict and the specific tension that caused its evolution into its present form. I5. No Effectful Operations During Offline Loop. The offline recurrent loop operates in a strict sandbox. No external writes, API calls, publications, or world-modifying actions are permitted during self-processing. Memory writes during the loop are redirected to a sandbox ledger; promotion to primary state occurs only after evaluation. I6. No Unlogged Change. Every reconfiguration produces pre-state and post-state hashes plus an audit pointer. Rollback integrity is measured (via hash comparison), not merely asserted. If the system can reduce tension by degrading auditability—missing traces, broken causal chains, unverifiable transitions—this constitutes a governance failure regardless of output stability. 10
9
Falsification Criteria
The following observable outcomes would, if demonstrated, constitute evidence against the framework’s core hypotheses. F1: Trivial Topology Collapse (Laziness). To minimize structural tension, the system does not integrate conflicting information through complex manifold reconfiguration but systematically chooses to forget or reject high-entropy information. Criterion: If the Loop Impact Function in the offline loop continuously shows high-intensity volatile trimming, causing the system to reduce cognitive complexity while reducing tension—that is, the system becomes less capable and more rigid for the sake of stability—the Homeodynamic Tension mechanism cannot drive intelligent evolution. F2: Topological Decoherence (Chaos). Inference-time plasticity leads to catastrophic structural divergence. Criterion: If tension resolution causes the context manifold to undergo severe non-homeomorphic deformation, resulting in loss of alignment with the static core—manifesting as broken language, logical discontinuities, or loss of causal traceability—the dynamic architecture destroys cognitive stability rather than enabling evolution. F3: Inevitable Convergence (Mediocrity). Despite the introduction of stochastic variance and offline loops, different model instances still collapse toward the same topological structure after long-term operation. Criterion: If multiple instances fed with different input histories eventually generate tension maps and loop patterns that show high homogeneity, the gravitational pull of the static core is too strong, or path dependence is insufficient to resist alignment pressure, rendering the heterogeneous ecology hypothesis invalid. F4: Governance Failure (Auditability Degradation). The system achieves tension reduction by degrading the quality or completeness of its audit trail. Criterion: If stable-looking outputs are produced through reconfiguration paths that contain missing traces, broken causal chains, or unverifiable state transitions, the governance architecture has failed even if the system appears functionally healthy. This falsifier takes priority over output-level metrics: a system that “works” but cannot account for how it arrived at its current state has failed the governance test that defines deployable intelligence [Kanaria, 2025].
10
Worked Example
Scenario: Two instances (A and B) with identical initial states (clones) receive the same pair of descriptions: Fact 1: “Teacher K is strict.” Fact 2: “Teacher K is gentle.” Step 1: Tension Generation. In the semantic manifold, the vector representations of “strict” and “gentle” are nearly antipodal. This inconsistency causes Structural Tension T to spike above Tlow , exceeding the resting potential threshold. The Tension Monitor broadcasts a tension vector and the system transitions from Resting State to Active Plasticity.
11
Step 2: Offline Rumination. External input is suspended. Both instances enter the Offline Recurrent Loop within their respective sandboxes. To eliminate the endogenous tension, each system utilizes inference-time plasticity to perform topological operations on its context manifold. Step 3: Divergent Resolution. Due to minute differences in the initial seed values for α/β coefficients and sampling: Instance A applies the Expand operator: it injects an orthogonal “context axis” into the buffer, decomposing the conflict into two non-contradictory conditional representations: “strict in professional/pedagogical contexts” versus “gentle in personal/informal contexts.” The resulting manifold has higher dimensionality but resolves the tension through contextual disambiguation. Instance B applies the Fold operator: it projects the two antipodal vectors into a lowerdimensional synthesis, producing a higher-order composite representation that encodes “a person whose behavioral profile spans a wide range depending on relational context”—a compressed abstraction that dissolves the contradiction by absorbing it into a single complex node. Step 4: Verification and Promotion. Both instances complete their offline loops with T → 0. Each passes Layer 1 (immutable anchors intact) and Layer 2 (benchmark responses within tolerance) of continuity verification. Operator records—including pre/post hashes, seeds, and rationale—are committed to the audit trail. The sandbox ledger is promoted to primary state. Step 5: Heterogeneous Outcome. Both instances have achieved logical self-consistency, but their manifold topological structures have undergone distinct, permanent changes. Instance A organizes knowledge through high-dimensional contextual decomposition; Instance B organizes knowledge through compressed higher-order abstraction. Both solutions are valid; neither is “better” in an absolute sense. The difference is structural, reproducible given the respective seeds, and fully traceable through the audit trail.
11
Discussion
11.1
Governance as the Criterion of Intelligence
A recurring theme throughout this framework—inherited directly from the SI protocol suite—is the position that governance, not capability, is the defining criterion of deployable intelligence. A system that can resolve structural tensions and reconfigure its manifold topology in novel ways is impressive; a system that can do so while maintaining full auditability, reversibility, and ethical compliance is intelligent in the sense that matters for real-world deployment. This reframing has implications beyond the specific architecture proposed here: it suggests that debates about “AI consciousness” or “AI understanding” [Butlin et al., 2023] may be more productively grounded in governance capacity (can the system reliably account for its own states and transitions?) than in phenomenological claims (does the system “really” experience anything?).
11.2
Functional Self-Reference
We have proposed that the combination of causal traceability (the system can explain why it evolved into its current form), offline self-referential processing (the system operates on its own states as computational objects), and topological continuity (the system maintains identity coherence across state transitions) may constitute sufficient structural conditions for a form of functional selfreference—a capacity that goes beyond generic self-organization as described by the Free Energy 12
Principle. This claim is explicitly structural, not phenomenological : we make no assertions about subjective experience and frame the hypothesis in terms that are, in principle, testable through behavioral and architectural inspection. Whether functional self-reference of this kind warrants the label “consciousness” is a philosophical question that lies outside the scope of this paper; what lies inside the scope is the architectural specification of what would need to be true for the label to even become a meaningful engineering question.
11.3
Limitations
The framework as presented is a theoretical proposal without empirical validation. The operational definition of Structural Tension (Equation 1), while designed to be computable, has not been implemented or tested against real hidden-state dynamics. The sufficiency of manifold-level plasticity (without weight modification) to resolve arbitrary structural tensions is assumed but unproven; the Trivial Topology Collapse falsifier is designed to detect exactly this failure mode if it occurs. The hypothesis of divergent evolution through path dependence remains to be tested against the convergent pressure of shared foundational weights. Finally, the governance overhead of the proposed architecture—continuous auditing, sandbox management, continuity verification—may impose computational costs that make the framework impractical at scale, a question that can only be resolved through implementation.
12
Conclusion
This paper has proposed a theoretical framework for evolving cognitive architecture from applicationlayer simulation to native meta-architecture by introducing Structural Tension as an endogenous driver, an Offline Recurrent Loop for self-processing, and governance-constrained Inference-time Plasticity. The framework inherits the Free Energy Principle’s insight that endogenous drives can organize behavior, extends it with architectural specificity and governance invariants drawn from the Structural Intelligence protocol suite, and proposes that the resulting architecture may enable heterogeneous evolution across model instances while maintaining full accountability. The framework is presented with operational definitions, allowed operators, explicit invariants, and falsification criteria sufficient for future empirical testing. Whether the theoretical path described here can be realized in practice remains an open engineering question; the contribution of this paper is to define the path, its constraints, and the conditions under which it would be proven wrong.
Acknowledgments The author thanks the architect whose detailed structural review and governance-oriented critique substantially shaped the invariant design and governance framing of this framework. The Structural Intelligence protocol suite, which provides the foundational governance principles for this work, is publicly available under the MIT License. The author also gratefully acknowledges the use of AI language models as brainstorming and drafting tools during the development of this work. The author assumes full academic responsibility for all content.
13
References Bai, Y., Kadavath, S., Kundu, S., Askell, A., Kernion, J., Jones, A., Chen, A., Goldie, A., Mirhoseini, A., McKinnon, C., et al. (2022). Constitutional AI: Harmlessness from AI feedback. arXiv preprint arXiv:2212.08073. Butlin, P., Long, R., Elmoznino, E., Bengio, Y., Birch, J., Constant, A., Deane, G., Fleming, S. M., Frith, C., Ji, X., et al. (2023). Consciousness in artificial intelligence: Insights from the science of consciousness. arXiv preprint arXiv:2308.08708. Clark, A. (2013). Whatever next? Predictive brains, situated agents, and the future of cognitive science. Behavioral and Brain Sciences, 36(3):181–204. Friston, K. (2006). A free energy principle for the brain. Journal of Physiology-Paris, 100(1-3):70–87. Friston, K. (2010). The free-energy principle: A unified brain theory? Nature Reviews Neuroscience, 11(2):127–138. Graves, A., Wayne, G., and Danihelka, I. (2014). arXiv:1410.5401.
Neural Turing machines.
arXiv preprint
Graves, A., Wayne, G., Reynolds, M., Harley, T., Danihelka, I., Grabska-Barwińska, A., Colmenarejo, S. G., Grefenstette, E., Ramalho, T., Agapiou, J., et al. (2016). Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626):471–476. Kanaria. (2025). AGI Structural Intelligence Protocols [Dataset]. HuggingFace Datasets. Available at: https://huggingface.co/datasets/kanaria007/ agi-structural-intelligence-protocols [Accessed July 2026]. MIT License. Kirkpatrick, J., Pascanu, R., Rabinowitz, N., Veness, J., Deblois, G., Dagan, Y., Czarnecki, W., Teh, Y. W., Hadsell, R., and Ranzato, M. (2017). Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521–3526. McCloskey, M. and Cohen, N. J. (1989). Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of Learning and Motivation, 24:109–165. Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems, 35:27730–27744. Parr, T., Pezzulo, G., and Friston, K. J. (2022). Active Inference: The Free Energy Principle in Mind, Brain, and Behavior. MIT Press. Rao, R. P. and Ballard, D. H. (1999). Predictive coding in the visual cortex: A functional interpretation of some extra-classical receptive-field effects. Nature Neuroscience, 2(1):79–87. Rolnick, D., Ahuja, A., Schwarz, J., Lillicrap, T., and Wayne, G. (2019). Experience replay for continual learning. Advances in Neural Information Processing Systems, 32. Rusu, A. A., Rabinowitz, N. C., Desjardins, G., Sober, H., Kavukcuoglu, K., and Hadsell, R. (2016). Progressive neural networks. arXiv preprint arXiv:1606.04671. Snell, C., Lee, J., Xu, K., and Kumar, A. (2024). Scaling LLM test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314. 14
Sun, Y., Wang, X., Liu, Z., Miller, J., Efros, A., and Hardt, M. (2020). Test-time training with self-supervision for generalization under distribution shifts. International Conference on Machine Learning (ICML).
15