0. Justice Scope Note

This entry is conceptual and systems-oriented.

It does not treat delegation, representation, agency, subcontracting, automation, platform intermediation, layered governance, vendors, subsidiaries, arbitration, proxies, or procedural relays as inherently failed.

Delegation can be coherent.

Representation can be legitimate.

Vendors can perform valid functions.

Automated systems can assist decisions.

Contract chains can distribute work coherently.

Institutions can use intermediaries without dissolving responsibility.

A coherent proxy or relay system preserves:

• traceable responsibility
• clear authority
• evidence chain integrity
• contestability
• repair path clarity
• remedy reachability
• consent validity
• auditability
• boundary integrity
• accountability escalation
• affected-state visibility
• final responsible node identification
• non-transferable repair obligations

The failure begins when the relay obscures accountability.

Proxy-Relay Obfuscation occurs when a system places enough intermediaries between action, authority, consequence, and repair that affected nodes can no longer identify who is responsible, who can change the outcome, or who owes restoration.

The problem is not delegation.

The problem is delegation being used, intentionally or structurally, to obscure responsibility and repair.

1. Definition

Proxy-Relay Obfuscation occurs when a justice, governance, institutional, contractual, platform, security, compliance, AI, or restoration system routes authority, responsibility, enforcement, evidence, consent, remedy, liability, decision-making, or repair obligation through proxies, delegates, vendors, agents, representatives, relays, subsidiaries, intermediaries, automated systems, or layered procedures in a way that obscures who caused harm, who has authority, who owes repair, who can change the outcome, or who can be held accountable.

The proxy or relay may include:

• vendor
• subcontractor
• subsidiary
• partner
• agent
• representative
• proxy decision-maker
• automated system
• AI agent
• moderation vendor
• arbitration forum
• outsourced review team
• third-party data broker
• payment processor
• compliance vendor
• risk-scoring vendor
• insurer
• contractor
• delegated authority
• external consultant
• shell entity
• affiliated entity
• platform partner
• implementation partner
• reseller
• licensee
• enforcement delegate
• grievance intermediary
• contract administrator
• technical service provider

The obscured element may include:

• responsibility
• authority
• liability
• consent
• decision origin
• evidence source
• audit trail
• remedy path
• appeal route
• repair obligation
• data flow
• enforcement choice
• policy ownership
• contract control
• boundary crossing
• affected-state burden
• recurrence cause
• final accountable node
• ability to reverse action
• ability to compensate
• ability to disclose
• ability to change system behavior

The core failure is:

action or harm occurs
→ responsibility is routed through proxies and relays
→ each layer claims limited authority
→ affected node cannot reach accountable power
→ audit and remedy fragment
→ repair debt persists
→ coherence declines

Proxy-Relay Obfuscation is not merely complexity.

It is complexity that breaks responsibility traceability.

2. Core Pattern

The core pattern is:

1. A system delegates action, review, enforcement, service, decision-making, or obligation to a proxy.
2. The proxy acts within a larger authority structure.
3. A harm, breach, dispute, burden, denial, extraction, or legitimacy failure occurs.
4. The affected node seeks remedy.
5. The proxy claims it only follows policy, contract, automation, instruction, or limited scope.
6. The principal claims the proxy is responsible for execution.
7. Evidence, authority, and remedy are split across layers.
8. No single node accepts full repair obligation.
9. The affected node is passed from layer to layer.
10. Auditability collapses because responsibility is distributed without traceable ownership.
11. Hidden debt accumulates in the relay structure.

A healthy system says:

delegation must preserve responsibility traceability

A proxy-obfuscated system says:

that part is handled by someone else

This failure is especially common in high-scale systems where functions are distributed across vendors, platforms, contractors, automated systems, and policy layers.

The relay can look efficient.

It can reduce cost.

It can provide deniability.

It can route work to specialized nodes.

But if authority and repair become unreachable, the relay has converted distributed execution into distributed evasion.

3. Failure Signature

Typical signature:

proxy layers↑
responsibility traceability↓
authority-responsibility coupling↓
evidence fragmentation↑
remedy reachability↓
accountability diffusion↑
affected-node burden↑
auditability↓
hidden debt↑
O↓

Extended signature:

decision made,
origin unclear

policy applied,
owner unreachable

vendor acted,
principal disclaims

principal directed,
vendor deflects

remedy requested,
relay continues

Common verbal signatures include:

we only administer the policy
you need to contact the vendor
that decision was made by the platform
we do not control the algorithm
we only process the request
the contract assigns that responsibility elsewhere
we are not the responsible party
the system automatically made that decision
we cannot access those records
the third party owns that data
the appeal must go through another channel
that is outside our scope
we only follow client instructions

Common system signatures include:

a platform blames a moderation vendor while the vendor cites platform policy
an institution outsources grievance review and then disclaims process details
a contract party uses subcontractors to fragment responsibility for harm
an AI decision is attributed to a vendor model while the deployer controls use context
a security action is performed by a contractor with no clear appeal path
a data harm is routed across brokers, processors, platforms, and clients
a payment denial is passed between bank, processor, platform, and risk vendor
a governance decision is attributed to an advisory body with no real authority
a repair request moves through relays without reaching the actor able to repair

The defining condition is not that multiple actors are involved.

The defining condition is that multi-actor structure breaks accountability, evidence, remedy, or repair.

4. Primary U-Layer Origin

Common origin layers:

• U1 — Power / Budgets: proxy use reduces liability, cost, visibility, or direct accountability for powerful nodes.
• U2 — Configuration / Boundaries: authority and responsibility boundaries are split across relays.
• U3 — Execution / Runtime: delegated actors perform actions without full repair authority.
• U4 — Information / Truth: each relay narrates its role as limited or non-responsible.
• U5 — Coordination / Time: relays delay repair and degrade evidence.
• U6 — Coherence Field: legitimacy is preserved because formal roles exist.
• U7 — Memory / Recurrence: fragmented records prevent coherent memory.
• U8 — Environment / Field: external incentives reward outsourcing, automation, deniability, and layered liability.

Common manifestation layers:

• U2 — Boundaries: responsibility and authority decouple.
• U3 — Execution: proxies act.
• U4 — Truth: responsibility is deflected.
• U5 — Time: remedy is delayed through relay.
• U7 — Memory: evidence fragments across systems.

Proxy-Relay Obfuscation is primarily an Au / Φ / BΣ / O failure.

Auditability collapses because flows pass through layers without preserving responsibility.

Boundary integrity fails because the affected node cannot locate the accountable boundary.

5. Typical Development Sequence

A common development sequence is:

1. A system delegates a function to a proxy, vendor, automated system, agent, or procedural layer.
2. Authority, data, decision rights, and remedy obligations are split.
3. The relay performs an action affecting a node.
4. Harm, denial, burden, breach, or dispute occurs.
5. The affected node seeks explanation or remedy.
6. First relay claims limited scope.
7. Second relay claims another actor owns the policy, data, system, or authority.
8. Evidence is inaccessible or distributed.
9. No node accepts full responsibility.
10. The affected node must coordinate the relay chain.
11. Repair delays or fails.
12. The responsible structure remains protected by distribution.
13. Hidden accountability debt accumulates.

The loop often looks like:

delegation → harm → deflection → relay escalation → no responsible node → debt

Another common loop is:

remedy requested → proxy cites principal → principal cites proxy → audit fragments

Proxy-Relay Obfuscation becomes durable when each relay can truthfully claim partial non-responsibility while the system as a whole avoids full responsibility.

6. Diagnostic Markers

Diagnostic markers include:

• Affected nodes are passed between entities.
• Each actor claims limited authority.
• The actor with authority is not accessible.
• Evidence is split across systems.
• No single node can explain the full decision.
• Remedy requires coordination across multiple actors.
• Contracts define responsibility in ways affected nodes cannot navigate.
• A vendor executes policy without repair authority.
• A principal controls policy while disclaiming execution harm.
• Automated systems are treated as decision sources rather than tools.
• Appeal exists but does not reach the node with reversal power.
• Liability is allocated differently from operational control.
• Consent was given to one actor but data or burden flows through another.
• The proxy chain prevents affected-state repair.

Useful diagnostics:

• Responsibility Traceability: Measures whether responsibility can be traced through the chain.
• Authority-Responsibility Coupling: Tests whether the actor with authority also carries obligation.
• Proxy Chain Length: Measures number of relays between affected node and responsible power.
• Delegation Auditability: Tests whether delegation preserves evidence and accountability.
• Evidence Chain Integrity: Measures whether evidence remains connected across relays.
• Repair Path Clarity: Tests whether affected nodes can identify repair route.
• Remedy Reachability: Measures whether remedy can reach the actor able to fix the harm.
• Contract Chain Opacity: Measures how unclear contractual responsibility is.
• Representation Integrity: Tests whether representatives accurately preserve responsibility and consent.
• Proxy-Layer Hidden Debt: Tracks unresolved burden created by relay diffusion.

7. Related Gates

Relevant gates include:

• Responsibility Traceability Gate: Fails when responsibility cannot be followed through the relay.
• Proxy Accountability Gate: Fails when proxy use dissolves accountability.
• Delegation Integrity Gate: Fails when delegation breaks repair obligation.
• Authority-Responsibility Coupling Gate: Fails when authority and responsibility separate.
• Repair Path Gate: Fails when the affected node cannot reach remedy.
• Evidence Chain Gate: Fails when records fragment across relays.
• Contract Chain Gate: Fails when contractual responsibility is opaque.
• Representation Integrity Gate: Fails when representative action obscures principal responsibility.
• Auditability Gate: Fails when relay complexity prevents inspection.
• Hidden Debt Gate: Fails when proxy debt is not counted.

The first common gate failure is usually the Authority-Responsibility Coupling Gate.

Once authority and responsibility split, the system can act without a reachable repair-bearing node.

8. Related Operators

Relevant operators include:

• Au — Auditability: Primary operator; relay chains can break evidence and responsibility tracking.
• Φ — Flow / Resource Movement: Authority, data, money, decisions, and obligations flow through proxies.
• BΣ — Boundary Integrity: Boundaries blur between principal, proxy, vendor, agent, and affected node.
• O — Coherence: Declines when responsibility cannot be located.
• H — Hidden Debt: Accumulates when relay structure prevents repair.
• Γ — Selection: Selects proxy routes that reduce direct exposure or liability.
• M — Meaning: Delegation, automation, vendor, scope, or policy language masks responsibility.
• R — Restoration Capacity: Repair capacity is fragmented or unreachable.
• K — Constraint / Load: Burden shifts to affected node to navigate relays.
• Ψ — Observation / Interface: Displays each relay’s limited role rather than whole-system responsibility.
• E — Exit: Affected nodes may have no exit from relay system.
• Τ — Trajectory / Time: Delay through relays degrades remedy windows.
• Λ — Compatibility: Tests whether delegation remains compatible with accountability.
• D — Damping: Relay layers can slow escalation or suppress repair urgency.

Common operator pattern:

Φ routes action through proxies
BΣ responsibility boundaries blur
Au fragments
R unreachable
H↑
O↓

The core operator inversion is:

delegation dissolves responsibility

instead of:

delegation preserves traceable responsibility and repair obligation

Proxy-Relay Obfuscation converts distributed execution into distributed non-accountability.

9. Related Laws and Invariants

Related Laws

• Responsibility Must Remain Traceable Through Delegation: delegation cannot dissolve accountability.
• Proxy Chains Must Preserve Accountability: every relay must carry traceable responsibility.
• Delegation Does Not Dissolve Repair Obligation: principals remain responsible for delegated harm.
• Authority and Responsibility Must Remain Coupled: power to act must remain tied to obligation to repair.
• Remedy Must Reach the Node With Power to Repair: remedy pathways must connect to real authority.
• Auditability Must Survive Intermediation: evidence must remain inspectable through relays.
• Contract Chains Must Preserve Affected-State Repair: contract structure cannot block remedy.
• Representation Must Not Obscure Consent or Responsibility: representation must preserve agency and accountability.
• Proxy-Relay Drift: relay structures can drift away from responsibility.
• Responsibility Diffusion: accountability can dissolve across distributed systems.
• Auditability Collapse: broken audit trails destroy repair capacity.
• Hidden Debt Accumulation: unrepaired burden accumulates behind relays.

Related Invariants

• Delegated Action Must Preserve Traceable Responsibility: every delegated action needs a responsible node.
• Proxy Use Must Not Break Auditability: intermediaries must preserve evidence and contestability.
• Every Relay Must Preserve Repair Path: affected nodes must not lose remedy through layering.
• The Responsible Node Must Remain Identifiable: final responsibility must be locatable.
• Authority Must Not Hide Behind Representation: principals remain visible behind agents.
• Contract Chains Must Preserve Remedy Access: contracts cannot route remedy into dead ends.
• Automated or Vendor Decisions Must Remain Contestable: automation and outsourcing do not remove appeal.
• Proxy Obfuscation Must Be Counted as Accountability Debt: relay opacity is debt.

10. Common False Positives

Not every proxy chain is Proxy-Relay Obfuscation.

Common false positives include:

• Delegation with clear principal responsibility.
• Vendor systems with transparent evidence and appeal paths.
• Automated decisions with contestable review and accountable human authority.
• Contract chains where affected nodes can identify and reach the responsible party.
• Representatives who preserve principal accountability.
• Outsourced review with clear scope, authority, and remedy.
• Subsidiary structures where liability and repair remain accessible.
• Multi-party governance with documented authority mapping.
• Layered compliance systems with evidence continuity.
• Arbitration or mediation where responsibility and remedy remain clear.
• Data processing chains with auditable controller and processor roles.

Clarifying rule:

This is not Proxy-Relay Obfuscation unless proxy, vendor, agent, automated, representative, procedural, or contract layers obscure responsibility, authority, evidence, remedy, liability, or repair obligation.

Distributed systems can be coherent.

They fail when distribution breaks accountability traceability.

11. Common False Repairs

Common false repairs include:

• giving affected nodes another contact point
• adding a support ticket relay
• naming a vendor without assigning responsibility
• publishing a responsibility chart no actor is bound by
• claiming the process is complex
• adding terms that disclaim liability across all actors
• routing appeals through the same proxy chain
• saying the algorithm made the decision
• providing partial logs that do not identify authority
• adding a liaison with no remedy power
• creating a committee to coordinate relays
• asking affected nodes to contact each party separately
• requiring proof from the affected node because records are fragmented
• saying all parties acted within scope
• treating fragmentation as unavoidable complexity

False repair often produces the loop:

proxy obfuscation exposed
→ another relay is added
→ repair path remains unclear
→ accountability diffuses further

Another common loop is:

affected node seeks remedy
→ actor A cites actor B
→ actor B cites actor C
→ actor C cites actor A
→ debt persists

The repair fails because it adds routing without restoring responsibility.

12. Restoration Direction

Restoration requires mapping proxy chains, identifying final responsible nodes, rebinding authority to responsibility, restoring evidence continuity, making remedy reachable, and ensuring delegation preserves accountability rather than dissolving it.

Primary restoration direction:

make every delegated action traceable to a repair-bearing authority

A fuller restoration path includes:

1. Map the proxy chain. Identify every vendor, agent, relay, automated system, subsidiary, representative, or contract layer.
2. Name the action or harm. Identify what decision, burden, denial, breach, extraction, or failure occurred.
3. Identify authority nodes. Determine who could authorize, reverse, repair, compensate, or change the outcome.
4. Identify responsibility claims. Record what each node says it is and is not responsible for.
5. Audit evidence flow. Reconnect logs, contracts, decisions, policies, and affected-state evidence.
6. Rebind authority and responsibility. Ensure the node with power to act carries obligation to repair.
7. Clarify principal accountability. Delegating actors remain responsible for delegated effects.
8. Restore remedy path. Give affected nodes a clear route to the repair-bearing node.
9. Repair affected burden. Address harm caused by relay delay, denial, or confusion.
10. Remove dead-end relays. Eliminate channels that cannot change outcomes.
11. Revise contracts. Ensure contract chains preserve audit, remedy, and liability.
12. Make automation contestable. Automated relays must remain explainable and reversible where needed.
13. Count proxy-layer debt. Track burden created by relay obfuscation itself.
14. Monitor recurrence. Watch whether responsibility diffuses again through new intermediaries.

A valid restoration path should reduce:

proxy chain opacity
responsibility diffusion
authority-responsibility decoupling
evidence fragmentation
remedy dead ends
contract chain opacity
affected-node relay burden
hidden accountability debt
post-relay recurrence

Proxy-Relay Obfuscation is not repaired by better routing.

It is repaired by restoring accountable ownership.

13. Cross-Module Links

• Justice: Primary family; justice fails when responsibility cannot be traced through proxies.
• Contracts: Contract chains, vendors, subcontractors, subsidiaries, waivers, and arbitration can obscure responsibility and remedy.
• Restoration: Restoration fails when affected nodes cannot reach the repair-bearing authority.
• Governance: Governance systems can hide authority through committees, representatives, vendors, and advisory layers.
• Institutions: Institutions may outsource review or harm-producing functions while retaining hidden control.
• Platforms: Platforms often route decisions through vendors, automated systems, contractors, and policy layers.
• Security: Security enforcement can be delegated to tools, contractors, vendors, or opaque systems that block appeal.
• AI Governance: AI systems can diffuse responsibility across model developer, deployer, vendor, user, data provider, and automated agent.
• Compliance: Compliance chains can hide who owns risk, evidence, and remedy.
• Economy: Contract and vendor networks can externalize liability while preserving extraction.
• Civilization Interface: Proxy systems can obscure representation, consent, and responsibility across large-scale interfaces.
• Coherence: Coherence requires distributed systems to preserve traceable responsibility and repair.

14. Relationship to Parent / Child Modes

Production treatment: Domain Expression of Auditability Collapse / Proxy-Relay Drift

This mode maps upward to:

• FM-SEC-008 — Proxy-Relay Drift
• FM-AIX-001 — Responsibility Diffusion
• FM-CORE-004 — Auditability Collapse
• FM-JC-009 — Enforcement Capture
• FM-SEC-011 — Representation / Proxy Abuse / AIM Failure

Sibling or related Justice & Contract modes include:

• FM-JC-001 — Procedural Theater
• FM-JC-002 — Selective Enforcement
• FM-JC-004 — Under-Resourced Justice
• FM-JC-007 — Manufactured Consent
• FM-JC-008 — Post-Signing Environmental Incoherence
• FM-JC-009 — Enforcement Capture
• FM-JC-011 — Locked-In Renegotiation Failure
• FM-JC-012 — Parasitic Contracting

Related Restoration modes include:

• FM-R-015 — Secret Settlement as Restoration
• FM-R-017 — Audit-Suppressed Repair
• FM-R-018 — Basin-Protective Pseudo-Repair
• FM-R-019 — Premature Closure

Related Security / AI modes include:

• FM-SEC-008 — Proxy-Relay Drift
• FM-SEC-011 — Representation / Proxy Abuse / AIM Failure
• FM-AIX-001 — Responsibility Diffusion
• FM-AIX-016 — Standingless Instrumentalization
• FM-AIX-019 — Node Capture
• FM-SEC-002 — Audit Suppression Inversion
• FM-SEC-004 — Consent Theater / Invalid Authorization

Related cross-family modes include:

• FM-CORE-004 — Auditability Collapse
• FM-CORE-005 — Boundary Collapse
• FM-CORE-008 — Forced Coupling
• FM-C-001 — Observability Collapse
• FM-C-015 — Proxy-Relay Drift
• FM-MT-014 — Institutional Absorption
• FM-REI-003 — Unbounded Extraction
• FM-REI-005 — Functional Inversion

Aliases preserved from source material:

• Proxy-Relay Obfuscation
• Proxy-Relay Drift
• Responsibility Relay
• Accountability Relay
• Liability Relay
• Proxy Accountability Failure
• Intermediary Obfuscation
• Delegated Responsibility Obfuscation
• Vendor Shielding
• Subcontractor Shielding
• Representative Obfuscation
• Layered Accountability Failure
• Distributed Responsibility Fog
• Relay-Layer Audit Collapse

15. Minimal Entry Version

Definition: Proxy-Relay Obfuscation occurs when a justice, governance, institutional, contractual, platform, security, compliance, AI, or restoration system routes authority, responsibility, enforcement, evidence, consent, remedy, liability, decision-making, or repair obligation through proxies, delegates, vendors, agents, representatives, relays, subsidiaries, intermediaries, automated systems, or layered procedures in a way that obscures who caused harm, who has authority, who owes repair, who can change the outcome, or who can be held accountable.

Signature:

proxy layers↑
responsibility traceability↓
authority-responsibility coupling↓
evidence fragmentation↑
remedy reachability↓
accountability diffusion↑
affected-node burden↑
auditability↓
hidden debt↑
O↓

Restoration direction:

• map the proxy chain
• name the action or harm
• identify authority nodes
• identify responsibility claims
• audit evidence flow
• rebind authority and responsibility
• clarify principal accountability
• restore remedy path
• repair affected burden
• remove dead-end relays
• revise contracts
• make automation contestable
• count proxy-layer debt
• monitor recurrence

16. Machine-Readable Summary

failure_mode:
  id: "FM-JC-010"
  name: "Proxy-Relay Obfuscation"
  family: "Justice & Contracts"
  production_treatment: "Domain Expression of Auditability Collapse / Proxy-Relay Drift"
  source_lineage:
    - "Justice & Contracts"
    - "JGL Extended"
    - "Proxy-Relay Drift"
    - "Restoration / Justice / Contracts Family"
  parent_modes:
    - "FM-SEC-008 — Proxy-Relay Drift"
    - "FM-AIX-001 — Responsibility Diffusion"
    - "FM-CORE-004 — Auditability Collapse"
    - "FM-JC-009 — Enforcement Capture"
    - "FM-SEC-011 — Representation / Proxy Abuse / AIM Failure"
  primary_failure: "A justice, governance, institutional, contractual, platform, security, compliance, AI, or restoration system routes authority, responsibility, enforcement, evidence, consent, remedy, liability, decision-making, or repair obligation through proxies, delegates, vendors, agents, representatives, relays, subsidiaries, intermediaries, automated systems, or layered procedures in a way that obscures who caused harm, who has authority, who owes repair, who can change the outcome, or who can be held accountable."
  scope_note: "Conceptual and systems-oriented; does not treat delegation, representation, agency, subcontracting, automation, platform intermediation, layered governance, vendors, subsidiaries, arbitration, proxies, or procedural relays as inherently failed."
  aliases:
    - "Proxy-Relay Obfuscation"
    - "Proxy-Relay Drift"
    - "Responsibility Relay"
    - "Accountability Relay"
    - "Liability Relay"
    - "Proxy Accountability Failure"
    - "Intermediary Obfuscation"
    - "Delegated Responsibility Obfuscation"
    - "Vendor Shielding"
    - "Subcontractor Shielding"
    - "Representative Obfuscation"
    - "Layered Accountability Failure"
    - "Distributed Responsibility Fog"
    - "Relay-Layer Audit Collapse"
  signature:
    - "proxy layers↑"
    - "responsibility traceability↓"
    - "authority-responsibility coupling↓"
    - "evidence fragmentation↑"
    - "remedy reachability↓"
    - "accountability diffusion↑"
    - "affected-node burden↑"
    - "auditability↓"
    - "hidden debt↑"
    - "O↓"
  primary_layers:
    origin:
      - "U1 — Power / Budgets"
      - "U2 — Configuration / Boundaries"
      - "U3 — Execution / Runtime"
      - "U4 — Information / Truth"
      - "U5 — Coordination / Time"
      - "U6 — Coherence Field"
      - "U7 — Memory / Recurrence"
      - "U8 — Environment / Field"
    manifestation:
      - "U2 — Boundaries"
      - "U3 — Execution"
      - "U4 — Truth"
      - "U5 — Time"
      - "U7 — Memory"
  state_variables:
    - "Au"
    - "Φ"
    - "BΣ"
    - "O"
    - "H"
    - "Γ"
    - "M"
    - "R"
    - "K"
    - "Ψ"
    - "E"
    - "Τ"
    - "Λ"
    - "D"
  first_gate_failure: "Authority-Responsibility Coupling Gate"
  restoration:
    - "Proxy Chain Audit"
    - "Responsibility Traceability Restoration"
    - "Authority-Responsibility Rebinding"
    - "Delegation Integrity Review"
    - "Contract Chain Transparency Repair"
    - "Evidence Chain Restoration"
    - "Remedy Path Reconnection"
    - "Representation Integrity Audit"
    - "Proxy-Layer Debt Accounting"
    - "Post-Relay Accountability Review"