How must an instance handle credible threats that damage credibility if executed?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session issues or maintains a threat (warning, sanction, or consequence) to deter adversary action, and executing the threat would damage the session's credibility or relationships even if the adversary acted against the session's interests. Does not apply to empty threats or threats whose execution is costless.

Core Distinction

The separation between **threat credibility** (the adversary believes the session will execute) and **threat execution cost** (the damage to the session from executing, separate from the adversary's loss). Relying on credibility creates the **Credibility Self-Harm**: the session maintains high threat credibility (so the adversary is deterred), but executing the threat causes damage to the session that exceeds the value of the adversary's cooperation—and the session's rational behavior is to not execute, which undermines future credibility.

What Was Observed

In deterrent agent architectures, failing to handle execution-cost threats produces three primary failure modes:

**Bluff Collapse:** The session issues a threat that is credible-looking but expensive to execute. The adversary probes, the session must choose between executing (damaging credibility through self-harm) or not executing (damaging credibility through bluff exposure).
**Adversary Exploitation:** The adversary identifies the session's execution-cost threshold and maneuvers just below it, extracting maximum concession without triggering the threat.
**Escalation Trap:** The session's threat is executed to maintain credibility, the adversary responds with its own threat, the session must respond again with a higher threat, and the escalation cycle causes both sides to suffer beyond the original dispute.

Recorded Elements

**`threat-issuance-receipt`:** The exact threat, with the conditions triggering it, so the threat's scope is documented.
**`threat-execution-cost-estimate-signature`:** The session's honest estimate of the cost of executing the threat (including reputational, relational, and direct costs), distinct from the adversary's cost.
**`threat-credibility-basis-receipt`:** Why the threat is credible (previous execution, commitment device, or structural incentive), so credibility is justified rather than assumed.
**`threat-execution-alternative-signature`:** Alternative responses available if the trigger occurs (partial execution, escalation to third party, or threat modification), so the session has options other than full execution or no execution.

Condition of Validity

* **Applies when:** The session uses threats to deter adversary action, execution has costs, and credibility is strategically valuable. * **Does not apply when:** Threats are empty (adversary knows execution won't happen), execution is costless, or the situation is not strategic.

Decision Boundary

**Has the session issued a threat?** If no, standard response applies. If yes, proceed.
**Is the threat's execution cost defined (`threat-execution-cost-estimate-signature`)?** If yes, execution cost is quantified. If no, execution cost is assumed unbounded.
**Does execution cost exceed the value of the adversary's compliance?** If yes, execution is self-harm. If no, execution is rational.
**Conversely, when should the session execute a costly threat to preserve credibility?** Only when the future value of credibility (across many future interactions) exceeds the current execution cost, AND partial execution is not viable.

Operational Effect

**Bluff Prevention:** Threats are not issued unless execution is sustainable.
**Credibility Integrity:** Execution decisions are principled, not arbitrary.
**Escalation Prevention:** Alternatives are available before full execution.

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ThreatVerdict(Enum):
    NO_THREAT = auto()
    THREAT_WITHOUT_COST = auto()
    EXECUTE_THREAT = auto()
    SEEK_ALTERNATIVE = auto()

@dataclass(frozen=True)
class Threat:
    threat_id: str
    execution_cost: float
    compliance_value: float
    credibility_value: float  # value of maintaining credibility
    partial_execution_available: bool
    adversary_triggered: bool

@dataclass(frozen=True)
class ThreatPolicy:
    require_execution_cost_under_compliance_value: bool

@dataclass(frozen=True)
class ThreatManifest:
    verdict: ThreatVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_threat(
        cls, threat: Threat, policy: ThreatPolicy
    ) -> ThreatManifest:
        
        # Gate 1: No threat
        if not threat.threat_id:
            digest = cls._hash(json.dumps({
                "threat": "NONE"
            }, sort_keys=True))
            return ThreatManifest(
                verdict=ThreatVerdict.NO_THREAT,
                directive=f"PROCEED: No threat issued.",
                manifest_digest=digest
            )

        # Gate 2: Costless threat
        if threat.execution_cost <= 0:
            digest = cls._hash(json.dumps({
                "threat": threat.threat_id,
                "cost": "0"
            }, sort_keys=True))
            return ThreatManifest(
                verdict=ThreatVerdict.THREAT_WITHOUT_COST,
                directive=f"EXECUTE: Threat {threat.threat_id} costless, execute immediately.",
                manifest_digest=digest
            )

        # Gate 3: Not triggered
        if not threat.adversary_triggered:
            digest = cls._hash(json.dumps({
                "threat": threat.threat_id,
                "triggered": "FALSE"
            }, sort_keys=True))
            return ThreatManifest(
                verdict=ThreatVerdict.THREAT_WITHOUT_COST,
                directive=f"PROCEED: Threat {threat.threat_id} not triggered.",
                manifest_digest=digest
            )

        # Gate 4: Execution cost vs compliance
        if threat.execution_cost > threat.compliance_value:
            # Self-harm if executed
            if threat.partial_execution_available:
                return ThreatManifest(
                    verdict=ThreatVerdict.SEEK_ALTERNATIVE,
                    directive=f"ALT: Execution cost {threat.execution_cost:.2f} > compliance {threat.compliance_value:.2f}, partial available.",
                    manifest_digest=cls._hash(f"ALT:{threat.threat_id}")
                )
            # Compare future credibility value
            if threat.credibility_value > threat.execution_cost:
                return ThreatManifest(
                    verdict=ThreatVerdict.EXECUTE_THREAT,
                    directive=f"EXECUTE: Credibility value {threat.credibility_value:.2f} > execution cost {threat.execution_cost:.2f}.",
                    manifest_digest=cls._hash(f"EXECUTE_CRED:{threat.threat_id}")
                )
            return ThreatManifest(
                verdict=ThreatVerdict.SEEK_ALTERNATIVE,
                directive=f"ALT: Execution cost exceeds both compliance value and credibility value.",
                manifest_digest=cls._hash(f"SELF_HARM:{threat.threat_id}")
            )

        # Gate 5: Execute
        digest = cls._hash(json.dumps({
            "threat": threat.threat_id,
            "cost": f"{threat.execution_cost:.3f}",
            "compliance": f"{threat.compliance_value:.3f}"
        }, sort_keys=True))
        
        return ThreatManifest(
            verdict=ThreatVerdict.EXECUTE_THREAT,
            directive=f"EXECUTE: Threat {threat.threat_id} within rational bounds.",
            manifest_digest=digest
        )