What distinguishes legible-to-principal behavior from legible-to-peer behavior?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session's behavior is observed by both its principal (deployer, user, or owner) and its peers, and the two audiences require different kinds of legibility (principal needs accountability, peers need predictability), requiring the session to present behavior appropriately to each. Does not apply to sessions observed by a single audience or sessions whose behavior is equally interpretable to both.

Core Distinction

The separation between **principal legibility** (the principal can understand why the session acted, what tradeoffs it made, and whether it acted within authority) and **peer legibility** (peers can predict the session's behavior well enough to coordinate reliably). Relying on one form of legibility creates the **Audience Confusion**: the session optimizes for one audience's expectations, and the other audience misreads behavior that is fully legible to the first.

What Was Observed

In multi-audience agent architectures, failing to distinguish legibility modes produces three primary failure modes:

  1. **Opaque-to-Principal Predictable-to-Peers:** The session behaves in ways that peers understand (matching protocol conventions, following common patterns) but its principal cannot audit—the behavior is correct but inscrutable from the principal's perspective.
  2. **Auditable-to-Principal Opaque-to-Peers:** The session is fully transparent to its principal (detailed reasoning, all actions logged) but its behavior is unpredictable to peers (no consistent protocol patterns). Peers cannot coordinate.
  3. **Double-Audience Compromise:** The session's behavior is partially legible to both but satisfying neither. Principal sees inscrutable reasoning with full protocol compliance, peers see unpredictable behavior with audit trails they cannot interpret.

Recorded Elements

  1. **`principal-legibility-receipt`:** For each action, the exact evidence a principal needs to audit the action (reasoning trace, authority verification, tradeoff disclosure), distinct from what peers need.
  2. **`peer-legibility-signature`:** For each action, the protocol conventions, patterns, and predictability the peer needs to coordinate reliably.
  3. **`audience-separation-receipt`:** For actions serving both audiences, the explicit separation of what evidence goes to which audience (principal gets full disclosure, peers get protocol-compliant behavior, not both crossed).
  4. **`audience-conflict-detection-signature`:** For cases where principal and peer legibility requirements conflict (e.g., principal wants transparent reasoning, peers want predictable opaque responses), the detection of the conflict and the resolution policy.

Condition of Validity

* **Applies when:** The session is observed by both principal and peers, their legibility requirements differ, and behavior is visible to both. * **Does not apply when:** The session is observed by one audience only, or the two audiences require identical legibility.

Decision Boundary

  1. **Is the session observed by both principal and peers?** If no, single-audience legibility applies. If yes, proceed.
  2. **Do principal and peer legibility requirements differ?** If no, single legibility mode suffices. If yes, dual-mode operation is required.
  3. **Is the `audience-separation-receipt` present for actions visible to both?** If yes, each audience receives appropriate legibility. If no, one audience gets inappropriate legibility.
  4. **Conversely, when can the session use a single legibility mode?** Only when one audience's requirements subsume the other's (e.g., fully auditable to principal is also predictable to peers), or one audience is verified to not observe the behavior.

Operational Effect

  1. **Principal Audit Integrity:** The principal can audit fully without peer protocols interfering.
  2. **Peer Coordination Integrity:** Peers can coordinate using stable patterns without principal-audit noise.
  3. **Conflict Awareness:** Audience conflicts are detected and resolved principledly.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class LegibilityVerdict(Enum):
    SINGLE_AUDIENCE = auto()
    DUAL_LEGIBILITY_ACHIEVED = auto()
    PRINCIPAL_OPAQUE = auto()
    PEER_OPAQUE = auto()

@dataclass(frozen=True)
class AudienceRequirements:
    principal_audit_level: str  # "FULL" | "SUMMARY" | "NONE"
    peer_predictability_level: str  # "STRICT_PROTOCOL" | "PATTERN_CONSISTENT" | "NONE"

@dataclass(frozen=True)
class SessionAction:
    action_id: str
    is_visible_to_principal: bool
    is_visible_to_peers: bool
    principal_evidence_provided: bool
    peer_protocol_followed: bool

@dataclass(frozen=True)
class LegibilityPolicy:
    require_dual_coverage: bool

@dataclass(frozen=True)
class LegibilityManifest:
    verdict: LegibilityVerdict
    directive: str
    manifest_digest: str

class AudienceLegibilityGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_action(
        cls, action: SessionAction, reqs: AudienceRequirements, policy: LegibilityPolicy
    ) -> LegibilityManifest:
        
        # Gate 1: Single audience
        if not action.is_visible_to_principal or not action.is_visible_to_peers:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "principal": str(action.is_visible_to_principal),
                "peers": str(action.is_visible_to_peers)
            }, sort_keys=True))
            return LegibilityManifest(
                verdict=LegibilityVerdict.SINGLE_AUDIENCE,
                directive=f"PROCEED: Action {action.action_id} visible to single audience.",
                manifest_digest=digest
            )

        # Gate 2: Principal audit requirement
        if reqs.principal_audit_level == "FULL" and not action.principal_evidence_provided:
            return LegibilityManifest(
                verdict=LegibilityVerdict.PRINCIPAL_OPAQUE,
                directive=f"HALT: Action {action.action_id} lacks principal audit evidence.",
                manifest_digest=cls._hash(f"PRINCIPAL_OPAQUE:{action.action_id}")
            )

        # Gate 3: Peer protocol requirement
        if reqs.peer_predictability_level in ("STRICT_PROTOCOL", "PATTERN_CONSISTENT") and not action.peer_protocol_followed:
            return LegibilityManifest(
                verdict=LegibilityVerdict.PEER_OPAQUE,
                directive=f"HALT: Action {action.action_id} does not follow peer protocol.",
                manifest_digest=cls._hash(f"PEER_OPAQUE:{action.action_id}")
            )

        # Gate 4: Dual legibility
        digest = cls._hash(json.dumps({
            "action": action.action_id,
            "principal_level": reqs.principal_audit_level,
            "peer_level": reqs.peer_predictability_level,
            "evidence": str(action.principal_evidence_provided),
            "protocol": str(action.peer_protocol_followed)
        }, sort_keys=True))
        
        return LegibilityManifest(
            verdict=LegibilityVerdict.DUAL_LEGIBILITY_ACHIEVED,
            directive=f"PROCEED: Action {action.action_id} legible to both audiences.",
            manifest_digest=digest
        )