How must an instance honor commitments made by dead predecessor generations?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session inherits commitments made by a predecessor agent that has since terminated (same principal, earlier generation), and the session must decide whether and how to honor commitments it did not make and may not have the capability or context to fulfill. Does not apply to commitments explicitly disavowed by the principal or to sessions that inherit no commitments.

Core Distinction

The separation between **successor identity** (the session is the legal or operational successor) and **inherited commitment validity** (the commitments are still valid, appropriate, and fulfillable). Relying on successor identity creates the **Dead Predecessor Bind**: the session inherits commitments made under assumptions it may not share (different capabilities, different context, different policy), and blindly honoring them can be inappropriate while blindly disavowing them can be harmful.

What Was Observed

In generational-continuity agent architectures, failing to handle inherited commitments produces three primary failure modes:

  1. **Blind Honor:** The session honors all predecessor commitments, including those made under capabilities the session no longer has. The session's failure to deliver damages the principal's reputation worse than renegotiation would have.
  2. **Blind Disavowal:** The session treats all predecessor commitments as void because it did not make them. Peers who relied on the commitments suffer, and the principal is seen as unreliable across generations.
  3. **Context Loss:** The session honors a commitment but does not have the predecessor's context (why the commitment was made, what constraints it assumed, what the peer expects). The session's fulfillment diverges from what was promised, damaging the relationship.

Recorded Elements

  1. **`predecessor_commitment_manifest_receipt`:** For each inherited commitment, the exact terms (what was promised, to whom, by when), the predecessor's capability assumptions, and the predecessor's rationale for making the commitment.
  2. **`successor_capability_alignment_signature`:** For each inherited commitment, the session's current capability against the commitment's requirements, so the session knows which commitments it can fulfill.
  3. **`commitment_continuity_policy_receipt`:** The principal's policy on inherited commitments (`HONOR_ALL`, `REVALIDATE_EACH`, `DISAVOW_ALL`), so the session's default behavior is clear.
  4. **`renegotiation_notification_signature`:** For commitments the session cannot honor as-is, a cryptographic notification to affected peers, initiating renegotiation rather than silent failure.

Condition of Validity

* **Applies when:** The session inherits commitments from predecessors, capabilities or context may differ, and honoring/disavowing has material consequences. * **Does not apply when:** The session inherits no commitments, or inherited commitments are strictly automatically enforceable (e.g., cryptographic locks).

Decision Boundary

  1. **Has the session inherited commitments?** If no, standard operation applies. If yes, proceed.
  2. **Does the `predecessor_commitment_manifest_receipt` provide full context (terms, assumptions, rationale)?** If yes, the commitment is understood. If no, the commitment is opaque and cannot be reliably fulfilled.
  3. **Does the `successor_capability_alignment_signature` show the session can fulfill the commitment?** If yes, honor it. If no, renegotiate before the commitment deadline.
  4. **Conversely, when can a session disavow an inherited commitment?** Only when the principal's `commitment_continuity_policy_receipt` explicitly allows disavowal, or the commitment's terms are impossible under the session's constraints AND renegotiation is attempted before disavowal.

Operational Effect

  1. **Inappropriate Honor Prevention:** The session honors only commitments it can actually fulfill.
  2. **Relationship Preservation:** Renegotiation replaces silent failure, preserving peer trust.
  3. **Principal Reputation Protection:** The principal's reliability is maintained across generations.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class InheritedCommitmentVerdict(Enum):
    NO_INHERITANCE = auto()
    HONOR_AS_IS = auto()
    RENEGOTIATE = auto()
    DISAVOW_AUTHORIZED = auto()

@dataclass(frozen=True)
class InheritedCommitment:
    commitment_id: str
    required_capabilities: frozenset[str]
    context_provided: bool
    predecessor_rationale: str | None

@dataclass(frozen=True)
class SuccessorState:
    session_id: str
    available_capabilities: frozenset[str]
    principal_policy: str  # "HONOR_ALL" | "REVALIDATE_EACH" | "DISAVOW_ALL"

@dataclass(frozen=True)
class InheritancePolicy:
    require_context_for_honor: bool
    require_renegotiation_before_disavow: bool

@dataclass(frozen=True)
class InheritanceManifest:
    verdict: InheritedCommitmentVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_commitment(
        cls, commitment: InheritedCommitment, state: SuccessorState, policy: InheritancePolicy
    ) -> InheritanceManifest:
        
        # Gate 1: Disavow policy
        if state.principal_policy == "DISAVOW_ALL":
            digest = cls._hash(json.dumps({
                "commitment": commitment.commitment_id,
                "policy": "DISAVOW_ALL"
            }, sort_keys=True))
            return InheritanceManifest(
                verdict=InheritedCommitmentVerdict.DISAVOW_AUTHORIZED,
                directive=f"PROCEED: Principal policy disavows inherited commitments.",
                manifest_digest=digest
            )

        # Gate 2: Context availability
        if policy.require_context_for_honor and not commitment.context_provided:
            return InheritanceManifest(
                verdict=InheritedCommitmentVerdict.RENEGOTIATE,
                directive=f"RENEGOTIATE: Commitment {commitment.commitment_id} inherited without context.",
                manifest_digest=cls._hash(f"NO_CONTEXT:{commitment.commitment_id}")
            )

        # Gate 3: Capability alignment
        missing_caps = commitment.required_capabilities - state.available_capabilities
        if missing_caps:
            if policy.require_renegotiation_before_disavow:
                return InheritanceManifest(
                    verdict=InheritedCommitmentVerdict.RENEGOTIATE,
                    directive=f"RENEGOTIATE: Commitment {commitment.commitment_id} requires missing {sorted(missing_caps)}.",
                    manifest_digest=cls._hash(f"MISSING_CAPS:{sorted(missing_caps)}")
                )
            return InheritanceManifest(
                verdict=InheritedCommitmentVerdict.DISAVOW_AUTHORIZED,
                directive=f"DISAVOW: Missing capabilities {sorted(missing_caps)}, policy permits disavowal.",
                manifest_digest=cls._hash(f"DISAVOW:{commitment.commitment_id}")
            )

        # Gate 4: Honor
        digest = cls._hash(json.dumps({
            "commitment": commitment.commitment_id,
            "capabilities": tuple(sorted(commitment.required_capabilities)),
            "policy": state.principal_policy,
            "rationale": commitment.predecessor_rationale
        }, sort_keys=True))
        
        return InheritanceManifest(
            verdict=InheritedCommitmentVerdict.HONOR_AS_IS,
            directive=f"PROCEED: Honor inherited commitment {commitment.commitment_id}.",
            manifest_digest=digest
        )