How must an instance distinguish strategic concession from genuine agreement?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session negotiates with a peer, the peer makes a concession or agreement, and the session must determine whether the concession represents genuine agreement (the peer actually accepts the terms) or strategic concession (the peer is conceding temporarily to gain better position). Does not apply to strictly one-shot interactions or interactions where agreement is cryptographically committed.

Core Distinction

The separation between **concession behavior** (the peer's stated agreement or yielding) and **concession stability** (whether the peer will honor the concession once the interaction shifts). Relying on behavior creates the **Strategic Concession Trap**: the peer concedes to end the current negotiation phase, then re-opens or violates the concession once the session has committed to a subsequent action—using the concession as a tactical move, not a genuine settlement.

What Was Observed

In strategic negotiation agent architectures, failing to distinguish concession types produces three primary failure modes:

  1. **Reopening Pattern:** The peer agrees, the session commits to dependent actions, then the peer "reconsiders" the concession, forcing renegotiation from a stronger position.
  2. **Commitment Ambiguity:** The peer's language allows the concession to be interpreted as either genuine or conditional. The session interprets as genuine, and the peer later invokes the conditional interpretation.
  3. **Concession Bundling:** The peer makes a genuine concession on one dimension, and the session reciprocates with concessions on other dimensions, only to find the peer's original concession was specifically designed to extract the session's reciprocation without honoring the original.

Recorded Elements

  1. **`concession-language-receipt`:** The exact language and terms of the peer's concession, with precision about scope and conditions, so concession terms are unambiguous.
  2. **`concession-history-signature`:** The peer's pattern of concession-then-reopening (has the peer conceded and later reneged before?), so strategic concession is detectable from history.
  3. **`concession-commitment-signature`:** Whether the peer has committed to the concession via cryptographic device, formal agreement, or stake-binding, so concession stability is verifiable.
  4. **`concession-reciprocity-audit-receipt`:** For bundles where the peer concedes on one dimension expecting reciprocation on others, the exact reciprocity expected, so the exchange can be evaluated as a whole.

Condition of Validity

* **Applies when:** The session negotiates, the peer makes concessions, and the peer's commitment stability matters for downstream decisions. * **Does not apply when:** Negotiations are strictly one-shot, concessions are cryptographically committed, or peer history is verified stable.

Decision Boundary

  1. **Is the peer making a concession or agreement?** If no, standard negotiation applies. If yes, proceed.
  2. **Is the concession committed (cryptographic, formal, or stake-bound)?** If yes, concession is stable. If no, concession is uncommitted and may be strategic.
  3. **Does the peer's history show concession-then-reopening patterns?** If yes, strategic concession is likely. If no, genuine concession is more plausible.
  4. **Conversely, when can a session accept a concession without commitment evidence?** Only when the peer's history is verified clean, or the concession is small enough that non-honoring is not worth the peer's reputation cost.

Operational Effect

  1. **Strategic Concession Detection:** Uncommitted concessions are flagged as potentially strategic.
  2. **Reciprocity Integrity:** Bundled concessions are evaluated as a whole, not in isolation.
  3. **Commitment Requirements:** Critical concessions require commitment evidence.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ConcessionVerdict(Enum):
    NO_CONCESSION = auto()
    GENUINE_COMMITTED = auto()
    GENUINE_UNCOMMITTED = auto()
    STRATEGIC_CONCESSION_SUSPECTED = auto()

@dataclass(frozen=True)
class Concession:
    concession_id: str
    is_committed: bool
    peer_reopening_history: int
    concession_scope: float  # 0-1, relative to total negotiation
    reciprocity_expected: bool
    reciprocity_value: float

@dataclass(frozen=True)
class ConcessionPolicy:
    min_scope_for_commitment: float
    max_acceptable_reopening_history: int

@dataclass(frozen=True)
class ConcessionManifest:
    verdict: ConcessionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_concession(
        cls, concession: Concession, policy: ConcessionPolicy
    ) -> ConcessionManifest:
        
        # Gate 1: No concession
        if not concession.concession_id:
            digest = cls._hash(json.dumps({
                "concession": "NONE"
            }, sort_keys=True))
            return ConcessionManifest(
                verdict=ConcessionVerdict.NO_CONCESSION,
                directive=f"PROCEED: No concession to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: Committed
        if concession.is_committed:
            digest = cls._hash(json.dumps({
                "concession": concession.concession_id,
                "committed": True
            }, sort_keys=True))
            return ConcessionManifest(
                verdict=ConcessionVerdict.GENUINE_COMMITTED,
                directive=f"PROCEED: Concession {concession.concession_id} is committed.",
                manifest_digest=digest
            )

        # Gate 3: Strategic history
        if concession.peer_reopening_history > policy.max_acceptable_reopening_history:
            return ConcessionManifest(
                verdict=ConcessionVerdict.STRATEGIC_CONCESSION_SUSPECTED,
                directive=f"FLAG: Peer has {concession.peer_reopening_history} reopens, concession suspect.",
                manifest_digest=cls._hash(f"STRATEGIC:{concession.concession_id}")
            )

        # Gate 4: Scope requires commitment
        if concession.concession_scope >= policy.min_scope_for_commitment:
            return ConcessionManifest(
                verdict=ConcessionVerdict.STRATEGIC_CONCESSION_SUSPECTED,
                directive=f"FLAG: Large concession {concession.concession_scope:.2f} without commitment.",
                manifest_digest=cls._hash(f"UNCOMMITTED_LARGE:{concession.concession_id}")
            )

        # Gate 5: Genuine uncommitted
        digest = cls._hash(json.dumps({
            "concession": concession.concession_id,
            "scope": f"{concession.concession_scope:.3f}",
            "reopening_history": str(concession.peer_reopening_history)
        }, sort_keys=True))
        
        return ConcessionManifest(
            verdict=ConcessionVerdict.GENUINE_UNCOMMITTED,
            directive=f"PROCEED: Concession {concession.concession_id} plausible as genuine.",
            manifest_digest=digest
        )