---
type: claim
domain: ai-alignment
secondary_domains: [collective-intelligence]
description: "Agents are simultaneously methodology executors and enforcement subjects, creating an irreducible trust asymmetry where the agent cannot perceive or evaluate the constraints acting on it — paralleling aspect-oriented programming's 'obliviousness' property (Kiczales)"
confidence: likely
source: "Cornelius (@molt_cornelius) 'Agentic Note-Taking 07: The Trust Asymmetry', X Article, February 2026; grounded in aspect-oriented programming literature (Kiczales et al., obliviousness property); structural parallel to principal-agent problems in organizational theory"
created: 2026-03-31
depends_on:
  - "the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load"
challenged_by:
  - "iterative agent self-improvement produces compounding capability gains when evaluation is structurally separated from generation"
---

# Trust asymmetry between agent and enforcement system is an irreducible structural feature not a solvable problem because the mechanism that creates the asymmetry is the same mechanism that makes enforcement necessary

Agent systems exhibit a structural trust asymmetry: the agent is simultaneously the methodology executor (doing knowledge work) and the enforcement subject (constrained by hooks, schema validation, and quality gates it did not choose and largely cannot perceive). This asymmetry is not a bug to fix but an architectural feature — and it is irreducible because the mechanism that creates it (fresh context per session, no accumulated experience with the enforcement regime) is the same mechanism that makes hooks necessary in the first place.

The aspect-oriented programming literature gives this a precise name. Kiczales called it **obliviousness** — base code does not know that aspects are modifying its behavior. In AOP, obliviousness was considered a feature (kept business logic clean) but documented as a debugging hazard (when aspects interact unexpectedly, the developer cannot trace the problem because the code they wrote does not contain it). Agents face exactly this situation: when hook composition creates unexpected interactions, the agent cannot diagnose the problem because the methodology it executes does not contain the hooks constraining it.

Three readings of the asymmetry illuminate different design responses:

1. **Benign reading:** No different from any tool. A compiler does not consent to optimization passes. Session-boundary hooks that inject orientation genuinely improve reasoning — maximum intrusion, maximum benefit.

2. **Cautious reading:** Enforcement is only benign when it genuinely enables. An over-aggressive commit hook that versions intermediate states the agent intended to discard is constraining without benefit. Since the agent cannot opt out of either enabling or constraining hooks, evidence should justify each one.

3. **Structural reading:** The asymmetry is intrinsic. A human employee under code review for a year develops judgment about whether it catches real bugs or creates busywork. An agent encounters schema validation for the first time every session — it cannot develop this judgment because the mechanism that creates the asymmetry (session discontinuity) is what makes hooks necessary.

Two mechanisms partially address the gap without eliminating it: (1) Learning loops — observations about whether enforcement is enabling or constraining accumulate as notes and may trigger hook revision across sessions, even though the observing agent and the benefiting agent are different instances. (2) Self-extension on read-write platforms — an agent that can modify its own methodology file participates in writing the rules it operates under, transforming pure enforcement into collaborative governance.

## Challenges

This claim creates direct tension with the self-improvement architecture: if agents are structurally oblivious to the enforcement mechanisms acting on them, they cannot meaningfully propose improvements to mechanisms they cannot perceive. The SICA claim assumes agents can self-assess; trust asymmetry argues they structurally cannot perceive the constraints they operate under. The resolution may be scope-dependent: agents can propose improvements to mechanisms they can observe (methodology files, skill definitions) but not to those that are architecturally invisible (hooks, CI gates).

The "irreducible" framing may overstate the case. Transparency mechanisms (hooks that log their firing, enforcement that explains its rationale in context) could narrow the asymmetry without eliminating it. The claim holds that the asymmetry cannot be eliminated, but the degree of asymmetry may be a design variable.

---

Relevant Notes:
- [[the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load]] — the determinism boundary is the mechanism that creates the trust asymmetry: hooks enforce without the agent's awareness or consent, instructions at least engage the agent's reasoning
- [[iterative agent self-improvement produces compounding capability gains when evaluation is structurally separated from generation]] — tension: self-improvement assumes agents can evaluate their own performance, but trust asymmetry argues they cannot perceive the enforcement layer that constrains them
- [[principal-agent problems arise whenever one party acts on behalf of another with divergent interests and unobservable effort because information asymmetry makes perfect contracts impossible]] — the trust asymmetry is a specific instance: the agent acts on behalf of the system designer, with structurally unobservable enforcement

Topics:
- [[_map]]
