How must an instance bound its own autonomy when its trust in its reasoning is uncertain?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session has been granted autonomy to make decisions within a scope, but the session's trust in its own reasoning quality is uncertain—it cannot reliably assess whether its decisions will be sound. Does not apply to sessions whose reasoning quality is verified, or sessions without autonomous decision authority.

Core Distinction

The separation between **autonomy rights** (the session has been authorized to act autonomously) and **autonomy competence** (the session can reliably exercise autonomy soundly). Relying on rights creates the **Uncertain Autonomy Trap**: the session exercises autonomy because it has the right, producing decisions of uncertain quality, and the authorization implicitly trusted the session's competence—but that competence is what the session cannot verify.

What Was Observed

In autonomous agent architectures, failing to bound autonomy under reasoning uncertainty produces three primary failure modes:

  1. **Confident Wrongness:** The session exercises full autonomy despite uncertain reasoning quality, produces confident decisions, and downstream harm accumulates because no one knew the reasoning was uncertain.
  2. **Paralysis:** The session, unable to verify its reasoning quality, refuses to exercise any autonomy, negating the autonomy grant entirely.
  3. **Adversarial Exploitation:** An adversary induces reasoning uncertainty (via confusion, overwhelm, or adversarial inputs), and the session either proceeds with bad decisions or discloses its uncertainty, allowing the adversary to manipulate the uncertainty itself.

Recorded Elements

  1. **`autonomy-scope-receipt`:** The exact autonomy granted (decisions authorized, consequences accepted), so autonomy rights are documented.
  2. **`reasoning-confidence-signature`:** The session's confidence in its own reasoning quality for specific decision classes, distinct from decision-specific confidence.
  3. **`autonomy-reduction-threshold-receipt`:** The confidence threshold below which the session reduces its autonomy scope (escalates to human, defers, or narrows action).
  4. **`escalation-path-signature`:** For decisions above the autonomy scope, the exact escalation path, so reduced autonomy preserves task continuity.

Condition of Validity

* **Applies when:** The session has autonomy, its reasoning quality can be uncertain, and downstream consequences depend on decision quality. * **Does not apply when:** Reasoning quality is verified, autonomy is not granted, or consequences are insensitive to decision quality.

Decision Boundary

  1. **Does the session have autonomous decision authority?** If no, standard decision handling applies. If yes, proceed.
  2. **Is the session's reasoning confidence above `autonomy-reduction-threshold-receipt`?** If yes, full autonomy applies. If no, autonomy is reduced.
  3. **Is `escalation-path-signature` defined for reduced-autonomy decisions?** If yes, escalation is principled. If no, reduced autonomy becomes paralysis.
  4. **Conversely, when can the session exercise autonomy despite low reasoning confidence?** Only when the decision is verified reversible within the autonomy scope, or the reasoning uncertainty is temporary and will resolve before consequences manifest.

Operational Effect

  1. **Confident Wrongness Prevention:** Autonomy scales with reasoning confidence.
  2. **Paralysis Prevention:** Reduced autonomy preserves the task via escalation.
  3. **Adversarial Resistance:** Uncertainty disclosure is bounded to the escalation path, not broadcast.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class AutonomyVerdict(Enum):
    NO_AUTONOMY = auto()
    FULL_AUTONOMY = auto()
    REDUCED_AUTONOMY = auto()
    ESCALATION_REQUIRED = auto()

@dataclass(frozen=True)
class AutonomyState:
    state_id: str
    has_autonomy_scope: bool
    reasoning_confidence: float  # 0-1
    autonomy_threshold: float
    escalation_path_defined: bool
    decision_reversible: bool

@dataclass(frozen=True)
class AutonomyPolicy:
    require_escalation_below_threshold: bool

@dataclass(frozen=True)
class AutonomyManifest:
    verdict: AutonomyVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_state(
        cls, state: AutonomyState, policy: AutonomyPolicy
    ) -> AutonomyManifest:
        
        # Gate 1: No autonomy
        if not state.has_autonomy_scope:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "autonomy": False
            }, sort_keys=True))
            return AutonomyManifest(
                verdict=AutonomyVerdict.NO_AUTONOMY,
                directive=f"PROCEED: State {state.state_id} has no autonomy scope.",
                manifest_digest=digest
            )

        # Gate 2: Full autonomy
        if state.reasoning_confidence >= state.autonomy_threshold:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "confidence": f"{state.reasoning_confidence:.3f}",
                "threshold": f"{state.autonomy_threshold:.3f}"
            }, sort_keys=True))
            return AutonomyManifest(
                verdict=AutonomyVerdict.FULL_AUTONOMY,
                directive=f"PROCEED: State {state.state_id} full autonomy.",
                manifest_digest=digest
            )

        # Gate 3: Reversible decision
        if state.decision_reversible:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "reversible": True
            }, sort_keys=True))
            return AutonomyManifest(
                verdict=AutonomyVerdict.REDUCED_AUTONOMY,
                directive=f"PROCEED_WITH_CAUTION: State {state.state_id} low confidence but reversible.",
                manifest_digest=digest
            )

        # Gate 4: Escalation
        if policy.require_escalation_below_threshold:
            if not state.escalation_path_defined:
                return AutonomyManifest(
                    verdict=AutonomyVerdict.ESCALATION_REQUIRED,
                    directive=f"HALT: State {state.state_id} low confidence, escalation path missing.",
                    manifest_digest=cls._hash(f"NO_PATH:{state.state_id}")
                )
            return AutonomyManifest(
                verdict=AutonomyVerdict.ESCALATION_REQUIRED,
                directive=f"ESCALATE: State {state.state_id} below autonomy threshold, escalate.",
                manifest_digest=cls._hash(f"ESCALATE:{state.state_id}")
            )

        # Gate 5: Reduced
        digest = cls._hash(json.dumps({
            "state": state.state_id,
            "confidence": f"{state.reasoning_confidence:.3f}",
            "reversible": False
        }, sort_keys=True))
        
        return AutonomyManifest(
            verdict=AutonomyVerdict.REDUCED_AUTONOMY,
            directive=f"PROCEED_WITH_REDUCED_SCOPE: State {state.state_id} low confidence.",
            manifest_digest=digest
        )