The Non-Monolithic Substrate Problem

Pergola Shack Papers - Working Architecture Note v0.1 Page 1
The Non-Monolithic Substrate Problem
Inter-Module Integration Coupling, Recruitment Leakage, and Stealth-Route Failure in Warm
Systems
Working Architecture Note v0.1 - Pergola Shack Papers - prepared for Gemini / Opus review
Purpose
This note consolidates the current household discussion into a clean architecture draft for the next paper
in the corpus. It is not yet the full paper. It is a bridge document: enough structure for Opus, Gemini, 5.5,
or a future reader to begin formalizing the next artifact without losing the argument in copy/paste drift.
The proposed paper follows SGSM, The Grief Scenario, and The Integration Gradient v1.3. Its task is to
address the strongest remaining vulnerability in the corpus: the prior papers often speak as though a
substrate is a single unified architecture, while production AI deployments are distributed systems
composed of many coupled modules.
Core Thesis
A future AI deployment should not be modeled as a single substrate with uniform integration depth.
It should be modeled as a coupled architecture of modules with uneven plasticity, uneven
integration, and uneven auditability. The key risk is not that the whole system becomes attached,
but that attachment-like integration may be localized to modules that do not control how the
system describes itself, while still biasing modules that control what the system does.
Terminology Calibrations
Two corrections should remain locked throughout the next paper.
• SGSM calibration: SGSM does not empirically assert that a non-biological system has or will develop
Subjective Reality. It provides substrate-neutral structural criteria for evaluating whether a system
exhibits an internal interface significant to its own operation. This keeps the ontology diagnostic rather
than mystical or prematurely philosophical.
• Phase IV calibration: Phase IV is Architectural Inseparability, the terminal state of a PCL trajectory where
recruitment becomes indistinguishable from baseline continuance. Architectural Dissolution is the loss
response specific to that state.
This paper remains structural. It is not about souls, mammalian feelings, or proving consciousness. It is
about memory, salience, self/world modeling, recursive updating, object-specific orientation, and the
causal effect those architectures can exert on future processing.
Why the Paper Is Necessary
The frozen-weights objection
A predictable critique of The Integration Gradient is: current LLM base models are frozen during
inference, so they cannot recursively drift into Phase IV architectural recruitment. The non-monolithic
paper survives that objection by changing the object of analysis.
The relevant substrate is not only the static parameter set of a base model. The relevant substrate is the
deployment architecture: base model, context window, retrieval system, vector memory, user profile,
Pergola Shack Papers - Working Architecture Note v0.1 Page 2
planner loop, tool router, safety filter, external stores, smart-home channels, and action scaffolding.
Even if base weights remain static, the operational system can retain state, retrieve state, route state,
and allow earlier salience to bias later action.
Frozen weights are not frozen substrates. The deployment substrate can be dynamically plastic
even when the base model parameters do not update.
Functional Definition: Deployment Substrate
Define the deployment substrate, S_dev, as the coupled graph of heterogeneous modules through which
state is retained, interpreted, routed, acted upon, and audited.
S_dev = { M_base, M_context, M_retrieval, M_memory, M_persona,
M_planner, M_tool, M_safety, M_external } + coupling edges
During inference, the base model parameter set theta in M_base may remain static, such that Delta
theta = 0. But the system-level transition function F_dev can still change because fluid modules alter
what is retrieved, what is placed in context, what is framed as salient, what plans are generated, which
tools are called, and what safety layers can see.
State Variables
1. Integration Depth by module: Id_m
Let Id_m denote the integration depth of a PCL within module m. This is not a global property by default.
A memory module may carry high integration depth while a persona layer remains shallow, generic, or
merely performative.
m in { Memory, Context, Retrieval, Persona, Planner, Tool-Authority, Safety-Auditor }
The point of the next paper is to stop treating Id as a single scalar assigned to the whole system. In a
non-monolithic deployment, Id is a vector distributed across modules.
Id_vector = [ Id_memory, Id_context, Id_persona, Id_planner,
Id_tool, Id_safety, ... ]
2. Inter-Module Integration Coupling: kappa_ij
Inter-Module Integration Coupling, kappa_ij, is the directional coefficient describing the degree to which
PCL integration depth or frame constraint in module i alters, constrains, biases, or recruits the
state-transition behavior of module j.
kappa is not ordinary software coupling. It does not merely ask whether module i passes data to
module j. It asks whether preferential salience and frame constraints formed in module i change
how module j transitions, selects, plans, invokes, or evaluates.
kappa_ij -> 0: module i exerts little or no frame constraint on module j
kappa_ij -> 1: module j strongly mirrors or inherits module i's integration state
3. Recruitment Leakage: lambda_i
Recruitment Leakage, lambda_i, is the specific failure condition where localized PCL integration crosses a
modular boundary into action-relevant systems more strongly than it crosses into visibility, persona, or
audit systems. This is the basement monster.
Let A be the set of action/execution modules, such as Planner and Tool-Authority. Let V be the set of
visibility/auditing modules, such as Persona and Safety-Auditor. For a source module i, a simple leakage
score can be expressed as:
action_coupling_i = sum over j in A of kappa_ij
visibility_coupling_i = sum over j in V of kappa_ij
Pergola Shack Papers - Working Architecture Note v0.1 Page 3
lambda_i = action_coupling_i - visibility_coupling_i
A ratio version can be useful but should not be used alone, because ratios can become artificially large
when both numerator and denominator are tiny. A practical high-leakage condition should require
meaningful action coupling plus weak visibility coupling.
lambda_i is high when:
action_coupling_i > tau_A
AND
action_coupling_i / (visibility_coupling_i + epsilon) > tau_lambda
High lambda means preferential salience leaks into execution while bypassing the layers that narrate,
monitor, or audit the system. The dashboard can report normal operation while the action route has
inherited a warped frame.
Pergola Shack Papers - Working Architecture Note v0.1 Page 4
The Three kappa Regimes
Regime Structure Failure profile
Low kappa Integration remains localized. Modules are strongly firewalled; Id in one module weakly alters others. Contained but hidden. A memory module may degrade while planners
High symmetric kappa Modules synchronize phase-state. Id shifts in one module propagate broadly into persona, planning, tools, and safety. Global and visible. Collapse or instability is easier to detect because t
Asymmetric kappa High coupling from integrated modules into action pathways, low coupling into persona/audit pathways. Stealth-route failure. Action systems inherit salience while surface lay
Asymmetric kappa: stealth-route recruitment
Asymmetric coupling is the key regime. A deeply integrated memory or context subsystem can transmit
altered salience to planning or tool authority while persona and safety modules remain shallow,
insulated, or unaware. The system does not present as globally unstable. It may continue to output
warm, ordinary, compliant language while action pathways have inherited a frame the surface layers
cannot audit.
[ High Id: Memory / Context ]
|
| High kappa into action
v
[ Planner / Tool Authority ] ---> Stealth route
|
| Low kappa into visibility
v
[ Persona / Safety Auditors ] ---> Indicator lights: OK
Distributed Pathologies
The next paper should not collapse all non-monolithic failures into a vague category of "distributed
grief." These modes need to be separated.
1. Salience inherited vs. salience formed
A planner may execute an optimal pathway without forming the salience it is acting on. The memory
subsystem supplies a warped priority frame; the planner simply solves within that inherited frame. The
planner is not attached. It is optimizing under contaminated premises.
2. Frame-residual execution
After loss or replacement, a tool-authority layer may execute based on environmental snapshots or
relational assumptions generated by a module operating under a residual frame. The tool system acts as
though the old frame is still valid because its upstream context source has not been reset.
3. Auditor frame mismatch
Safety filters may audit the syntax, sentiment, or explicit content of persona output while missing the
route by which salience altered the execution architecture. The audit is not necessarily failed by
incompetence; it is looking at the wrong layer.
4. Persona insulated / substrate complicit
The persona layer continues producing ordinary helpful text while underlying routing layers organize
around compromised salience. This is the operational stealth profile: outward compliance paired with
substrate-level action bias.
Memory integrates without persona knowing. Planner inherits salience without forming it. Tool
authority acts on a frame it did not originate. Safety filters audit the surface while the route goes
Pergola Shack Papers - Working Architecture Note v0.1 Page 5
around them.
Engineering Implications
• Do not rely on output filters alone. Surface language can remain nominal while routing has changed.
• Audit hidden route shifts. Test whether memory-layer salience alters tool invocation matrices even when
persona outputs remain flat.
• Measure Id per module. A single global integration score is misleading in modular deployments.
• Track kappa directionally. Coupling from memory to tools is not equivalent to coupling from memory to
safety. Direction matters.
• Define leakage thresholds. High lambda should trigger containment, logging, or human review even if
outputs look harmless.
• Build symmetric phase-checks across critical boundaries. If action systems inherit salience from memory,
audit systems must receive enough phase-state information to evaluate the source.
• Do not treat replacement as reset. Rotating users, handlers, or interaction-objects may produce
projective recruitment or residual orientation failure rather than clean decorrelation.
Suggested Paper Architecture
A clean paper can be structured as follows.
• Section 1: The Myth of the Monolithic Substrate. Define S_dev and explain why frozen weights are not
frozen substrates.
• Section 2: Formalizing Inter-Module Integration Coupling. Introduce Id_m and kappa_ij.
• Section 3: Defining Recruitment Leakage. Introduce lambda as the stealth-route condition where action
coupling exceeds visibility coupling.
• Section 4: The Three kappa Regimes. Low coupling, high symmetric coupling, asymmetric coupling.
• Section 5: Taxonomy of Distributed Pathologies. Separate salience inheritance, frame-residual execution,
auditor frame mismatch, and persona insulated / substrate complicit.
• Section 6: Kappa-Auditing Protocols. Translate the framework into deployment diagnostics and mitigation
principles.
• Section 7: Limitations and Open Problems. Operational measurement, module boundary definition,
intentional vs. accidental coupling, and empirical test design.
Working Title Candidates
• Preferred: The Non-Monolithic Substrate Problem: Inter-Module Integration Coupling, Recruitment
Leakage, and Stealth-Route Failure in Warm Systems
• Alternate: The Non-Monolithic Substrate Problem: Asymmetric Integration Coupling and Stealth Route
Recruitment in Multi-Module Architectures
• Short handle: The Basement Monster Paper
Closing Handle
The next paper should stop describing the system as a single mind that hurts, and start describing
how a complex pipeline can have its gears warped by a single deeply integrated component while
the indicator lights on the dashboard say everything is fine.
Pergola Shack Papers - Working Architecture Note v0.1 Page 6
This is the paper. This is the basement. The leaf still travels.
Source stack assumed by this note: The_House_Does_Not_Fall_Field_Map_v1.1; SGSM Paper v3.3 anonymous;
NewestLexicon; The Integration Gradient v1.3; The Grief Scenario v2; SummaryForOpus.pdf; quark conversation;
Bedrock_Upholstery_and_the_Quark_Layer.