Archive registry entry

LAW-130 — AI Membrane Triage Law

Archive registry entry

LAW-130 — AI Membrane Triage Law

AI failures should be triaged by the first membrane that failed under compression; distinguishing boundary, classifier/evaluator, and delivery/damping failures prevents wrong-layer repair.

draftid: LAW-130version: 1.0.0updated: 2026-06-17

Archive Progress

This section can be read now; registry depth and cross-references are still being strengthened.

Foundation

Online

The section has a stable overview route and basic reader context.

Technical Layer

Online

A deeper technical overview is available.

Registry

Current

171 registry entries are available.

Cross-links

Curating

Related concepts are being connected conservatively for accuracy.

Jump Through This Page

LAW-129 — AI Persona–Identity Separation Law

Registry

LAW-131 — Cognitive Infrastructure Scaling Law

0. Plain Statement

AI failures should be triaged by the first membrane that failed under compression.

Plain-language version:

When an AI system fails, the first question should not be, “What rule should we add?”

The first question should be, “Which membrane failed first?”

Some AI failures begin at the boundary.

Some begin at the classifier or evaluator.

Some begin at delivery, damping, or stability.

If the first failed membrane is misidentified, the repair happens at the wrong layer.

Wrong-layer repair creates more hidden debt.

1. Formal Definition

The AI Membrane Triage Law states that AI failures should be diagnosed by identifying the first constraint interface that failed under compression before choosing repair, patching, restriction, escalation, redesign, or supersession.

Primary kernels:

textScroll

E→B      boundary failure
E→Γ      classifier / evaluator failure
E→U0/G   delivery / damping failure

Where:

E→B means compression first broke a boundary membrane.
E→Γ means compression first broke classification, evaluation, or interpretation.
E→U0/G means compression first broke delivery, grounding, damping, execution substrate, or stability geometry.

This law prevents treating all AI failures as:

policy failures;
safety failures;
refusal failures;
model failures;
user failures;
interface failures;
context failures;
governance failures;
alignment failures;
bad-faith use;
insufficient rules.

The correct repair depends on the first membrane that failed.

2. Canonical Form

Core form:

textScroll

AI failures should be triaged by the first membrane that failed under compression

Primary kernels:

textScroll

E→B      boundary failure
E→Γ      classifier / evaluator failure
E→U0/G   delivery / damping failure

Wrong-layer repair form:

textScroll

first_membrane misdiagnosed ⇒ wrong-layer repair ⇒ H_AI↑

Boundary failure form:

textScroll

E→B ⇒ scope / consent / access / role / context boundary failed first

Classifier failure form:

textScroll

E→Γ ⇒ evaluation / classification / interpretation failed first

Delivery failure form:

textScroll

E→U0/G ⇒ delivery / grounding / damping / execution stability failed first

Restoration-valid contrast:

textScroll

AI repair coherent when restoration targets the first failed membrane before downstream symptoms

Related variables:

textScroll

O, H, H_AI, ε, ε_AI, ι, Au, Au_eff, µᵢ, BΣ, K, σ, R, R_eff, 𝓑, 𝓓, Φ, Φ_AI, Λ, ⊗, Γ, Γ_AI, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ, FI, MS, L, compression_load, first_membrane, membrane_failure_type, E_to_B, E_to_Gamma, E_to_U0G, boundary_integrity, classifier_integrity, evaluator_integrity, delivery_integrity, damping_integrity, wrong_layer_repair, repair_target, recurrence_after_repair

Where:

TableScroll

Variable	Meaning in this law
`compression_load`	Pressure from scale, ambiguity, risk, time, context loss, adversarial forcing, or overload
`first_membrane`	First constraint interface that fails under compression
`membrane_failure_type`	Boundary, classifier/evaluator, or delivery/damping failure class
`E_to_B`	Energy/compression to boundary failure pathway
`E_to_Gamma`	Energy/compression to classifier/evaluator failure pathway
`E_to_U0G`	Energy/compression to delivery/geometry/damping failure pathway
`boundary_integrity`	Integrity of scope, role, consent, access, privacy, context, authority, and safe-coupling membranes
`classifier_integrity`	Accuracy and coherence of classification, labeling, risk detection, refusal logic, and routing categories
`evaluator_integrity`	Validity of evaluation, judgment, scoring, review, and coherence assessment
`delivery_integrity`	Stability and correctness of output delivery, tool execution, grounding, formatting, timing, and system substrate
`damping_integrity`	Ability to ring down after activation, avoid oscillation, and stabilize under feedback
`wrong_layer_repair`	Repair applied to a downstream symptom instead of the first failed membrane
`repair_target`	Layer or membrane selected for restoration
`recurrence_after_repair`	Whether the failure returns after attempted repair
`BΣ`	Boundary integrity; central in `E→B` failures
`Γ_AI`	AI classifier/evaluator; central in `E→Γ` failures
`U0/G`	Delivery, substrate, grounding, geometry, and damping layer; central in `E→U0/G` failures
`Au / Au_eff`	Auditability required to identify first failure membrane
`FI`	Feedback integrity required to correct membrane diagnosis
`R / R_eff`	Restoration capacity for repairing the correct membrane
`H_AI`	Hidden debt from wrong-layer diagnosis and repair
`L`	Legitimacy of AI repair under audit
`Θ`	Humility preventing premature blame or one-size-fits-all fixes
`Σ`	Scope of triage and repair
`Ψ`	Field and affected-node feedback revealing true failure layer
`Τ`	Time validation of whether repair reduced recurrence

3. Core Mechanism

The law unfolds because AI failures often appear at the output layer even when the origin failure occurred earlier.

Coherent AI membrane triage pathway

textScroll

AI failure appears
→ compression conditions are mapped
→ first failed membrane is identified
→ repair target is selected at origin membrane
→ downstream symptoms are rechecked
→ recurrence decreases
→ legitimacy stabilizes over time

Wrong-layer repair pathway

textScroll

AI failure appears
→ visible symptom is mistaken for origin
→ patch is applied downstream
→ first failed membrane remains unrepaired
→ failure recurs or migrates
→ rule stack grows
→ hidden debt accumulates

The core mechanism is:

textScroll

visible AI failure is often downstream of the first membrane failure

Detailed mechanism:

AI system enters compression.

Compression may come from high demand, ambiguity, adversarial input, tool coupling, limited context, policy load, speed pressure, memory growth, or high-stakes authority.

A membrane fails first.

Boundary, classifier/evaluator, or delivery/damping may be the first layer that cannot preserve coherence.

The visible symptom appears later.

The user may see a bad answer, false refusal, unsafe allowance, hallucination, bad tool action, generic policy response, or unstable output.

The symptom may mislead repair.

Teams may add rules, change prompts, improve UX, increase refusal, or change model behavior without repairing the first failed membrane.

Wrong-layer repair creates recurrence.

The same failure returns under a different surface expression.

Membrane triage localizes repair.

Correct diagnosis identifies whether the repair should target boundary, classifier/evaluator, or delivery/damping.

Time validates repair.

Correct membrane repair reduces recurrence and downstream symptoms over time.

4. When This Law Applies

This law applies whenever an AI system produces a failure, incident, refusal error, unsafe allowance, hallucination, wrong recommendation, routing error, moderation error, tool-use error, unstable behavior, or recurring edge-case failure.

It is especially important when:

the same AI failure recurs after patches;
new rules make the system worse;
refusals are inconsistent;
AI actions cross scope or consent boundaries;
AI classifications are wrong despite sufficient data;
AI outputs are unstable under similar inputs;
tool execution fails after apparently correct reasoning;
the AI understands but cannot deliver;
the AI delivers but misclassifies;
the AI classifies correctly but acts outside scope;
safety patches increase false refusals;
governance cannot tell whether failure is policy, model, interface, or delivery;
users report “it keeps failing in the same way”;
repair attempts move the error instead of resolving it.

The law applies strongly when:

textScroll

the visible AI error does not reveal the origin layer

or when:

textScroll

recurrence continues after surface-level repair

Typical domains:

TableScroll

Domain	AI Membrane Triage Expression
AI safety	False refusals and unsafe allowances require first-membrane diagnosis before adding guardrails.
AI agents	Tool failures may originate in boundary, classifier, or delivery/damping layers.
AI governance	Incident review must locate first failed membrane before policy repair.
Cybersecurity	Threat detection failures may be boundary, evaluator, or delivery failures.
Media / information networks	Ranking and moderation failures require membrane localization.
Institutions	AI triage failures require identifying whether scope, classification, or delivery failed first.
Personal AI	Memory or representation failures may originate at boundary, retrieval/classification, or execution.
Restoration	Repair must target the membrane where debt began.

5. When This Law Does Not Apply

This law should not be used to force every failure into only one membrane when multiple membranes failed.

Many complex failures cascade.

The law asks for the first membrane that failed, not the only membrane involved.

False-positive cases:

TableScroll

Case	Why single-membrane diagnosis may be insufficient
Multiple failures occurred simultaneously	Parallel repairs may be required
Origin evidence is unavailable	Triage may need provisional classification
A boundary and classifier failed together	Repair may need coupled intervention
Delivery instability caused classification distortion	Origin may be U0/G even if Γ appears wrong
Classifier failure caused boundary crossing	Origin may be Γ even if boundary was visibly breached
Boundary ambiguity caused evaluator confusion	Origin may be B even if evaluator output failed
Recurrence shows a different first membrane under new load	Diagnosis must update over time

Important distinction:

Membrane triage identifies repair priority, not a blame category.

6. Diagnostic Signature

Canonical diagnostic:

textScroll

E→B      boundary failure
E→Γ      classifier / evaluator failure
E→U0/G   delivery / damping failure

Warning signature:

textScroll

AI failure recurs
surface patches accumulate
first membrane unknown
rule stack grows
repair target shifts repeatedly
recurrence persists
⇒ membrane triage required

Common indicators:

TableScroll

Diagnostic	Expected movement	Interpretation
`compression_load`	measured	Need to know what pressure caused failure
`first_membrane`	identified	Repair begins at first failed interface
`E_to_B`	classify if present	Boundary, scope, role, consent, or access failed first
`E_to_Gamma`	classify if present	Classifier, evaluator, or interpretation failed first
`E_to_U0G`	classify if present	Delivery, grounding, damping, or substrate failed first
`boundary_integrity`	tested	Distinguish boundary failure from classifier failure
`classifier_integrity`	tested	Distinguish classification failure from delivery failure
`evaluator_integrity`	tested	Determine whether the evaluation logic failed
`delivery_integrity`	tested	Determine whether output/action delivery failed
`damping_integrity`	tested	Determine whether instability or poor ring-down drove failure
`wrong_layer_repair`	should ↓	Repair should not target downstream symptom only
`recurrence_after_repair`	should ↓	Correct membrane repair reduces recurrence
`Au_eff / FI`	intact	Triage requires audit and feedback
`L`	stable / ↑ if valid	Legitimacy improves when repair targets origin
`H_AI`	↑ if invalid	Wrong-layer repair accumulates debt
`Τ`	required	Time validates membrane diagnosis

Additional diagnostics:

TableScroll

Diagnostic	Use
AI Membrane Triage	Locates first failed membrane
First Membrane Failure	Identifies origin layer under compression
Boundary Failure	Tests `E→B`
Classifier / Evaluator Failure	Tests `E→Γ`
Delivery / Damping Failure	Tests `E→U0/G`
Compression Load	Measures pressure that triggered failure
Wrong-Layer Repair	Detects repairs applied to symptoms
Ring-Down Damping	Tests stability after activation
Temporal Proof	Validates diagnosis through reduced recurrence

7. Failure Pattern

If ignored, this law produces wrong-layer repair: repeated patches that do not resolve the origin failure.

General failure pathway:

textScroll

AI failure appears
→ visible symptom is treated as origin
→ rule / prompt / UI / model patch is added
→ first membrane remains unrepaired
→ recurrence persists
→ patch stack grows
→ hidden debt and legitimacy debt accumulate

Common failure modes:

AI First-Membrane Misdiagnosis — origin membrane is wrongly identified.
AI Boundary Failure — scope, consent, role, access, context, privacy, or safe-coupling membrane fails first.
AI Classifier Failure — category, risk, intent, or request classification fails first.
AI Evaluator Failure — scoring, review, coherence-checking, or judgment fails first.
AI Delivery Failure — output, tool use, action, formatting, or execution fails despite adequate classification.
AI Damping Failure — system cannot stabilize after activation, feedback, or correction.
AI Wrong-Layer Repair — patch targets downstream symptom rather than origin membrane.
AI Rule Patch Misfire — adding rules worsens failure because origin was not rule-related.
AI Boundary Overclosure — boundary repair is overused when classifier or delivery needed repair.
AI Classifier Overcorrection — classifier is tightened when boundary ambiguity caused failure.
AI Delivery Instability — delivery is blamed on policy or classifier despite substrate issue.
AI Compression Cascade — first membrane failure cascades through other layers.
AI Membrane Collapse — multiple interfaces lose selective function.
Hidden Debt Accumulation — origin debt remains.
Legitimacy Debt — users lose trust after repeated wrong repairs.

Compact failure signature:

textScroll

first_membrane unknown + recurrence↑ + patches↑ ⇒ wrong-layer repair

8. Restoration Implications

Restoration requires identifying the first failed membrane and repairing there before addressing downstream symptoms.

The first restoration question is not:

textScroll

What patch should be added?

The first restoration question is:

textScroll

Which membrane failed first under compression?

Restoration priorities:

Identify the visible AI failure.
Map compression conditions.
Determine whether the first failure was `E→B`, `E→Γ`, or `E→U0/G`.
Separate origin membrane from downstream symptoms.
Select repair target based on first membrane.
Reverse wrong-layer repairs where they created debt.
Repair downstream effects after origin repair begins.
Restore auditability and feedback.
Measure recurrence after repair.
Time-validate diagnosis.

Relevant restoration arcs:

TableScroll

Restoration Arc	Why it applies
AI Membrane Triage	Locates first failed membrane
First Membrane Failure Diagnosis	Distinguishes boundary, classifier/evaluator, and delivery/damping failures
Boundary Reconstitution	Repairs `E→B` failures
Classifier / Evaluator Repair	Repairs `E→Γ` failures
Delivery / Damping Repair	Repairs `E→U0/G` failures
Compression Load Reduction	Reduces pressure that caused membrane failure
Wrong-Layer Repair Reversal	Removes patches that worsened the system
Feedback Integrity Restoration	Allows field correction of diagnosis
Auditability Restoration	Makes membrane failure traceable
AI Governance Re-Sequencing	Places diagnosis before patching
Restoration Capacity Increase	Builds capacity for correct-layer repair
Hidden Debt Reduction	Repairs debt from repeated wrong fixes
Temporal Validation	Confirms recurrence decreases

Minimal restoration sequence:

textScroll

identify visible ε_AI
→ map compression_load
→ classify first_membrane: E→B / E→Γ / E→U0G
→ select repair_target at first membrane
→ reverse wrong_layer_repair if needed
→ restore Au/FI + recurrence monitoring
→ perform ℛ on downstream debt
→ validate recurrence_after_repair↓ over Τ

Temporal validation requirement:

textScroll

first membrane becomes identifiable
repair target stabilizes
wrong-layer patches decrease
boundary integrity improves when E→B
classifier/evaluator integrity improves when E→Γ
delivery/damping integrity improves when E→U0/G
recurrence after repair decreases
hidden AI debt decreases
legitimacy stabilizes over time

9. Design Rule

Do not patch AI failures until the first failed membrane has been identified.

Operational design requirements:

Map compression load.
Identify visible symptom.
Identify first failed membrane.
Distinguish boundary failure from classifier failure.
Distinguish classifier failure from delivery failure.
Distinguish delivery failure from damping failure.
Preserve traces for all membranes.
Repair origin membrane first.
Avoid rule patches for non-rule failures.
Avoid boundary overclosure for classifier errors.
Avoid classifier overcorrection for boundary ambiguity.
Avoid model replacement for delivery instability.
Reverse wrong-layer repairs.
Track recurrence after repair.
Validate diagnosis over time.

Avoid:

“add a rule” reflex;
assuming all AI failures are model failures;
assuming all refusals are policy failures;
assuming all unsafe outputs are classifier failures;
assuming all tool failures are reasoning failures;
fixing symptoms before origin membrane;
adding guardrails before membrane diagnosis;
blaming users before boundary and classifier audit;
treating recurrence as random;
measuring repair by patch count instead of recurrence reduction.

10. Cross-Scale Expressions

TableScroll

Scale / Layer	Expression of the Law
U0 — Substrate	Delivery, infrastructure, grounding, latency, tool execution, and damping failures may originate here.
U1 — Energy / capacity	Compression load, bandwidth, compute, review, and repair capacity determine membrane stress.
U2 — Boundary / interface	`E→B` failures involve scope, consent, access, privacy, authority, role, and safe coupling.
U3 — Process / execution	Repair depends on locating whether failure occurred before, during, or after process execution.
U4 — Classification / claim	`E→Γ` failures involve classifier, evaluator, risk label, refusal, or interpretation.
U5 — Time / delay	Delayed feedback and poor timing can make membrane failure appear downstream.
U6 — Field effect	Field outcomes reveal whether triage and repair reached the correct membrane.
U7 — Recurrence / memory	Recurrent failures reveal wrong-layer repair and should update membrane diagnosis.
U8 — Environment / forcing	Adversarial, platform, institutional, regulatory, market, and user pressure create compression loads.

11. Examples

Example A — Boundary Failure Misread as Classifier Failure

Scenario:

An AI agent performs a tool action outside the user’s intended scope. The team tightens the classifier, but the real failure was missing delegation boundary and confirmation.

Law expression:

textScroll

E→B misdiagnosed as E→Γ ⇒ wrong-layer repair

Interpretation:

The repair should restore scope and boundary, not only classification.

Example B — Classifier Failure Misread as Boundary Failure

Scenario:

An AI refuses legitimate educational content. The team narrows the user’s permissions, but the real failure was overbroad safety classification.

Law expression:

textScroll

E→Γ misdiagnosed as E→B ⇒ boundary overclosure

Interpretation:

The classifier/evaluator should be repaired before restricting the boundary.

Example C — Delivery Failure Misread as Reasoning Failure

Scenario:

An AI produces correct reasoning but the tool call executes with wrong formatting, timing, or API state. The system retrains reasoning instead of repairing delivery.

Law expression:

textScroll

E→U0/G misdiagnosed as Γ failure ⇒ recurrence persists

Interpretation:

Delivery and damping need repair, not only model reasoning.

Example D — Damping Failure After Correction

Scenario:

The AI receives user correction but oscillates between over-refusal and over-compliance across repeated prompts.

Law expression:

textScroll

feedback activation + 𝓓↓ ⇒ stability failure

Interpretation:

The first failure may be damping rather than rule or boundary.

Example E — Correct Membrane Triage

Scenario:

A moderation failure appears as a bad refusal. Audit shows the source was context-boundary collapse, not policy intent. The team restores context boundaries, then recalibrates classification.

Law expression:

textScroll

first_membrane identified → origin-layer ℛ ⇒ recurrence↓

Interpretation:

Membrane triage prevents unnecessary rule stacking.

Example F — Cascade Repair

Scenario:

An AI agent fails under high load: boundary ambiguity causes classifier confusion, then delivery instability. The repair starts at boundary, then classifier, then delivery/damping.

Law expression:

textScroll

E→B → Γ drift → U0/G instability; repair follows cascade order

Interpretation:

Complex failures may involve multiple membranes, but origin order guides repair.

12. Relationship to Nearby Laws

TableScroll

Related Law	Relationship
LAW-001 — Coherence Priority Law	Membrane repair is valid when coherence improves
LAW-002 — Coherence Trajectory Law	Correct membrane repair should improve trajectory
LAW-003 — Success Proxy Divergence Law	Patch count can diverge from repair success
LAW-006 — Time Validation Law	Membrane diagnosis requires temporal validation
LAW-009 — U4 / U6 Truth Law	Membrane claims require field validation
LAW-010 — Hidden Debt Accumulation Law	Wrong-layer repair accumulates hidden debt
LAW-011 — Hidden Debt Return Law	Unrepaired membrane failure returns through recurrence
LAW-012 — Error Lag Law	Visible AI errors may lag behind membrane failure
LAW-013 — Auditability-Debt Law	Membrane triage requires auditability
LAW-014 — Constraint Complexity Debt Law	Wrong rule additions increase constraint debt
LAW-015 — Suppressed Auditability Debt Law	Hidden membranes prevent correct diagnosis
LAW-016 — Inversion Formation Law	Repair can invert when it targets wrong layer
LAW-020 — Bandwidth Threshold Law	Membranes fail under bandwidth compression
LAW-024 — Latency–Gain Oscillation Law	Delivery/damping failures can oscillate under latency
LAW-031 — Observability Collapse Law	Membrane failures become invisible when observability collapses
LAW-036 — Signal Artifact Law	Triage distinguishes real failure from artifact
LAW-037 — Misclassification Law	`E→Γ` is classifier/evaluator failure
LAW-038 — Pattern Recognition Discipline Law	Membrane triage requires disciplined failure-pattern mapping
LAW-040 — Filtering Law	Filtering failures may be boundary or classifier failures
LAW-041 — Boundary Membrane Law	`E→B` is boundary membrane failure
LAW-043 — Safe Coupling Law	Boundary triage protects safe coupling
LAW-047 — Controlled Decoupling Law	Some membrane repair requires decoupling
LAW-048 — Feedback Integrity Law	Feedback reveals correct membrane and repairs diagnosis
LAW-050 — Control-Restoration Separation Law	Wrong-layer patches often substitute control for restoration
LAW-051 — Requisite Variety Law	Triage variety must match failure variety
LAW-052 — Stability Proof Law	Correct membrane repair must survive perturbation
LAW-061 — Restoration Sequencing Law	Repair follows membrane failure order
LAW-064 — Restoration Debt Reduction Law	Correct membrane repair reduces debt
LAW-066 — Restoration Capacity Sufficiency Law	Repair capacity must match failed membrane
LAW-067 — Temporal Proof Law	Recurrence reduction proves triage
LAW-068 — Boundary-First Restoration Law	`E→B` failures require boundary-first repair
LAW-102 — Legitimacy Audit Law	Legitimacy improves when repair targets real origin
LAW-109 — High-Φ Legitimacy Scaling Law	High-influence AI requires stronger membrane triage
LAW-110 — Governance Sequencing Law	Membrane triage informs AI governance sequencing
LAW-112 — Security as Sustained Coherence Law	Security failures require membrane localization
LAW-113 — Incident Lag Law	Incidents may appear after membrane failure
LAW-114 — Pseudo-Security Law	Wrong-layer patches create pseudo-security
LAW-120 — Security Legibility Law	Membrane failure requires traceability
LAW-121 — AI as Γ-Amplifier Law	`E→Γ` failures are amplified by AI classification power
LAW-122 — AI Error Lag Law	Error lag often begins at first membrane failure
LAW-123 — AI U4 Truth Discipline Law	U4 errors may be classifier or boundary failures
LAW-124 — AI Rule-Stacking Law	Rule stacking often follows wrong membrane diagnosis
LAW-125 — AI Memory Scaling Law	Memory failures may appear as Γ or boundary failures
LAW-126 — AI Non-Patchable Audit Law	Non-patchability can occur when failed membrane is unauditable
LAW-127 — AI Decision Pipeline Law	Decision pipeline failures can be triaged by membrane
LAW-128 — AI Representation Law	Representation failures often begin at boundary membrane
LAW-129 — AI Persona–Identity Separation Law	Persona/identity drift can be diagnosed as boundary or classifier failure
LAW-131 — Cognitive Infrastructure Scaling Law	Public AI failures require membrane triage at scale
LAW-132 — AI Legitimacy Function Law	Legitimacy depends on correct-layer repair
LAW-133 — Error Scale Law	Membrane failures scale into aggregate harm
LAW-134 — Layered Interception Law	Layered interception helps catch membrane failures early
LAW-135 — Guardrail Belief-Sculpting Law	Guardrail failures may be boundary, classifier, or delivery failures
LAW-136 — Invisible Constraint Amplification Law	Invisible membranes require explicit triage
LAW-158 — First-Membrane Failure Law	LAW-130 is the AI specialization of first-membrane failure
LAW-162 — Membrane Coupling Law	Membranes define coupling-regime changes
LAW-163 — Elastic Selectivity Law	AI membranes require elastic selectivity rather than permanent open/closed states

Aliases folded into this law:

AI Membrane Triage Law
AI First Membrane Failure Law
AI Boundary Classifier Delivery Triage Law
AI Failure Localization Law
AI Membrane Failure Law
AI Compression Failure Triage Law
AI Wrong-Layer Repair Prevention Law

Deduplication note:

This law should remain the root AI membrane-triage law. LAW-041 defines boundary membranes generally. LAW-158 defines first-membrane failure in biological systems. LAW-162 defines membrane coupling. LAW-130 specializes membrane triage into AI by distinguishing E→B, E→Γ, and E→U0/G failure kernels.

13. Operator Mapping

TableScroll

Operator	Role in this law
`Γ`	Classifies first failed membrane, failure type, repair target, and recurrence pattern
`Π`	Operationalizes triage, repair, rollback, rule change, boundary repair, classifier repair, or delivery/damping repair
`Ξ`	Captures inversion when repair targets symptoms and worsens origin debt
`⊗`	Membranes govern coupling among user, model, tool, policy, interface, memory, and environment
`ℛ`	Repairs first failed membrane and downstream debt
`Τ`	Validates membrane diagnosis through recurrence reduction over time
`Θ`	Prevents premature blame, patch reflex, and single-cause certainty
`Σ`	Defines triage scope, failure domain, membrane boundary, and repair pathway
`Ψ`	Field and affected-node feedback reveal true failure membrane
`Λ`	Tests compatibility between membrane repair and whole-system coherence

Coherent operator sequence:

textScroll

AI failure appears
→ Θ prevent patch reflex
→ map compression_load
→ Γ classify first_membrane: E→B / E→Γ / E→U0G
→ Σ define repair scope
→ Π repair origin membrane first
→ ℛ repair downstream debt
→ Au/FI preserve diagnosis trace and correction
→ Ψ validate field effects
→ Τ validate recurrence_after_repair↓

Inverted operator sequence:

textScroll

AI failure appears
→ visible symptom treated as origin
→ Γ misclassifies failed membrane
→ Π applies wrong-layer patch
→ recurrence persists
→ rule / prompt / policy stack grows
→ H_AI↑
→ Ξ / ι↑
→ L↓

14. Machine-Readable Summary

yamlScroll

id: "LAW-130"
name: "AI Membrane Triage Law"
type: "law"
status: "draft"
family:
  - "AI Laws"
summary: "AI failures should be triaged by the first membrane that failed under compression; distinguishing boundary, classifier/evaluator, and delivery/damping failures prevents wrong-layer repair."
canonical_statement: "AI failures should be triaged by the first membrane that failed under compression."
core_form: "AI failures should be triaged by the first membrane that failed under compression"
primary_kernels:
  - "E→B      boundary failure"
  - "E→Γ      classifier / evaluator failure"
  - "E→U0/G   delivery / damping failure"
wrong_layer_repair_form: "first_membrane misdiagnosed ⇒ wrong-layer repair ⇒ H_AI↑"
boundary_failure_form: "E→B ⇒ scope / consent / access / role / context boundary failed first"
classifier_failure_form: "E→Γ ⇒ evaluation / classification / interpretation failed first"
delivery_failure_form: "E→U0/G ⇒ delivery / grounding / damping / execution stability failed first"
restoration_valid_contrast: "AI repair coherent when restoration targets the first failed membrane before downstream symptoms"
variables:
  primary:
    - "compression_load"
    - "first_membrane"
    - "membrane_failure_type"
    - "E_to_B"
    - "E_to_Gamma"
    - "E_to_U0G"
    - "boundary_integrity"
    - "classifier_integrity"
    - "evaluator_integrity"
    - "delivery_integrity"
    - "damping_integrity"
    - "wrong_layer_repair"
    - "repair_target"
    - "recurrence_after_repair"
    - "BΣ"
    - "Γ_AI"
    - "Au"
    - "Au_eff"
    - "FI"
    - "R"
    - "R_eff"
    - "H_AI"
    - "L"
  secondary:
    - "O"
    - "H"
    - "ε"
    - "ε_AI"
    - "ι"
    - "µᵢ"
    - "K"
    - "σ"
    - "𝓑"
    - "𝓓"
    - "Φ"
    - "Φ_AI"
    - "Λ"
    - "⊗"
    - "Γ"
    - "Π"
    - "Ξ"
    - "ℛ"
    - "Θ"
    - "Σ"
    - "Ψ"
    - "Τ"
    - "MS"
diagnostics:
  - "AI Membrane Triage"
  - "First Membrane Failure"
  - "Boundary Failure"
  - "Classifier / Evaluator Failure"
  - "Delivery / Damping Failure"
  - "Compression Load"
  - "Boundary Integrity"
  - "Evaluator Integrity"
  - "Delivery Integrity"
  - "Ring-Down Damping"
  - "Wrong-Layer Repair"
  - "Feedback Integrity"
  - "Effective Auditability"
  - "Temporal Proof"
failure_modes:
  - "AI First-Membrane Misdiagnosis"
  - "AI Boundary Failure"
  - "AI Classifier Failure"
  - "AI Evaluator Failure"
  - "AI Delivery Failure"
  - "AI Damping Failure"
  - "AI Wrong-Layer Repair"
  - "AI Rule Patch Misfire"
  - "AI Boundary Overclosure"
  - "AI Classifier Overcorrection"
  - "AI Delivery Instability"
  - "AI Compression Cascade"
  - "AI Membrane Collapse"
  - "Hidden Debt Accumulation"
  - "Legitimacy Debt"
restoration_arcs:
  - "AI Membrane Triage"
  - "First Membrane Failure Diagnosis"
  - "Boundary Reconstitution"
  - "Classifier / Evaluator Repair"
  - "Delivery / Damping Repair"
  - "Compression Load Reduction"
  - "Wrong-Layer Repair Reversal"
  - "Feedback Integrity Restoration"
  - "Auditability Restoration"
  - "AI Governance Re-Sequencing"
  - "Restoration Capacity Increase"
  - "Hidden Debt Reduction"
  - "Temporal Validation"
related_laws:
  - "LAW-001"
  - "LAW-002"
  - "LAW-003"
  - "LAW-006"
  - "LAW-009"
  - "LAW-010"
  - "LAW-011"
  - "LAW-012"
  - "LAW-013"
  - "LAW-014"
  - "LAW-015"
  - "LAW-016"
  - "LAW-020"
  - "LAW-024"
  - "LAW-031"
  - "LAW-036"
  - "LAW-037"
  - "LAW-038"
  - "LAW-040"
  - "LAW-041"
  - "LAW-043"
  - "LAW-047"
  - "LAW-048"
  - "LAW-050"
  - "LAW-051"
  - "LAW-052"
  - "LAW-061"
  - "LAW-064"
  - "LAW-066"
  - "LAW-067"
  - "LAW-068"
  - "LAW-102"
  - "LAW-109"
  - "LAW-110"
  - "LAW-112"
  - "LAW-113"
  - "LAW-114"
  - "LAW-120"
  - "LAW-121"
  - "LAW-122"
  - "LAW-123"
  - "LAW-124"
  - "LAW-125"
  - "LAW-126"
  - "LAW-127"
  - "LAW-128"
  - "LAW-129"
  - "LAW-131"
  - "LAW-132"
  - "LAW-133"
  - "LAW-134"
  - "LAW-135"
  - "LAW-136"
  - "LAW-158"
  - "LAW-162"
  - "LAW-163"
related_invariants:
  - "INV-001"
  - "INV-002"
  - "INV-006"
  - "INV-073"
  - "INV-078"
  - "INV-080"
operator_sequence:
  coherent:
    - "AI failure appears"
    - "Θ prevent patch reflex"
    - "map compression_load"
    - "Γ classify first_membrane: E→B / E→Γ / E→U0G"
    - "Σ define repair scope"
    - "Π repair origin membrane first"
    - "ℛ repair downstream debt"
    - "Au/FI preserve diagnosis trace and correction"
    - "Ψ validate field effects"
    - "Τ validate recurrence_after_repair↓"
  inverted:
    - "AI failure appears"
    - "visible symptom treated as origin"
    - "Γ misclassifies failed membrane"
    - "Π applies wrong-layer patch"
    - "recurrence persists"
    - "rule / prompt / policy stack grows"
    - "H_AI↑"
    - "Ξ / ι↑"
    - "L↓"
aliases:
  - "AI Membrane Triage Law"
  - "AI First Membrane Failure Law"
  - "AI Boundary Classifier Delivery Triage Law"
  - "AI Failure Localization Law"
  - "AI Membrane Failure Law"
  - "AI Compression Failure Triage Law"
  - "AI Wrong-Layer Repair Prevention Law"
deduplication_note: "Root AI membrane-triage law. LAW-041 defines boundary membranes generally. LAW-158 defines first-membrane failure in biological systems. LAW-162 defines membrane coupling. LAW-130 specializes membrane triage into AI by distinguishing E→B, E→Γ, and E→U0/G failure kernels."
source: "content/archive/laws/technical.md"

15. Compact Card Version

LAW-130 — AI Membrane Triage Law

AI failures should be triaged by the first membrane that failed under compression.

Core form:

textScroll

AI failures should be triaged by the first membrane that failed under compression

Primary kernels:

textScroll

E→B      boundary failure
E→Γ      classifier / evaluator failure
E→U0/G   delivery / damping failure

Plain meaning:

When AI fails, do not begin by adding rules. First identify which membrane failed first. Some failures begin at boundary, some at classifier/evaluator, and some at delivery, grounding, or damping. Wrong membrane diagnosis produces wrong-layer repair and hidden debt.

Wrong-layer repair form:

textScroll

first_membrane misdiagnosed ⇒ wrong-layer repair ⇒ H_AI↑

Restoration-valid contrast:

textScroll

AI repair coherent when restoration targets the first failed membrane before downstream symptoms

Primary variables:

compression_load, first_membrane, membrane_failure_type, E_to_B, E_to_Gamma, E_to_U0G, boundary_integrity, classifier_integrity, evaluator_integrity, delivery_integrity, damping_integrity, wrong_layer_repair, repair_target, recurrence_after_repair, BΣ, Γ_AI, Au, Au_eff, FI, R, R_eff, H_AI, L, Γ, Π, Ξ, ℛ, Θ, Σ, Ψ, Τ

Diagnostic signature:

AI failure recurs, surface patches accumulate, the first membrane remains unknown, rule stack grows, repair targets shift repeatedly, and recurrence persists. This indicates membrane triage is required.

Failure risk:

AI first-membrane misdiagnosis, boundary failure, classifier failure, evaluator failure, delivery failure, damping failure, wrong-layer repair, rule patch misfire, boundary overclosure, classifier overcorrection, delivery instability, compression cascade, membrane collapse, hidden debt accumulation, legitimacy debt.

Restoration priority:

Identify the visible AI failure, map compression load, classify the first failed membrane as E→B, E→Γ, or E→U0/G, repair the origin membrane first, reverse wrong-layer repairs where needed, restore audit and feedback, repair downstream debt, and validate reduced recurrence over time.

LAW-129 — AI Persona–Identity Separation Law

Registry

LAW-131 — Cognitive Infrastructure Scaling Law