How must an instance handle decision paralysis from adversarial information overload?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session must make a decision under information the adversary can flood with conflicting, ambiguous, or irrelevant data, and the flood induces paralysis—the session cannot decide because every decision is undermined by contradicting information. Does not apply to sessions whose decision inputs are adversary-isolated or whose decisions are trivially computable regardless of input volume.

Core Distinction

The separation between **information richness** (more information potentially enables better decisions) and **information overload** (more information becomes a decision-blocking attack surface). Relying on richness creates the **Overload Paralysis**: the session correctly refuses to decide without sufficient analysis, but the sufficient-analysis bar rises faster than the session's analysis capacity as the adversary floods inputs, and no decision is ever reached.

What Was Observed

In decision-under-adversary agent architectures, failing to bound overload produces three primary failure modes:

  1. **Contradiction Flood:** The adversary provides N conflicting sources for each claim. The session's consensus-building requires reconciling all N, and the reconciliation cost exceeds the session's capacity.
  2. **Relevance Diffusion:** The adversary adds irrelevant but plausible information that must be considered and dismissed. The dismissal cost grows linearly with the flood, and the decision never resolves.
  3. **Freshness Trap:** The adversary continuously adds "new evidence" that supersedes previous analysis. The session must re-analyze from scratch each time, and the analysis never catches up to the freshest evidence.

Recorded Elements

  1. **`information-intake-budget-receipt`:** The session's bound on information considered for a decision (maximum sources, time, or tokens), so intake is bounded regardless of flood.
  2. **`relevance-filter-signature`:** The session's relevance filter (which sources are considered, based on authority, recency, or verification), so irrelevant information is excluded without analysis.
  3. **`decision-sufficiency-predicate-receipt`:** The session's sufficiency predicate (which conditions must hold to decide), so the decision fires when conditions hold regardless of further information.
  4. **`adversarial-flood-detection-signature`:** The session's detection of flood patterns (contradiction rate above baseline, freshness churn above baseline), so flood is distinguished from normal information flow.

Condition of Validity

* **Applies when:** The session decides under information, adversaries can flood, and information volume affects decision feasibility. * **Does not apply when:** Decision inputs are adversary-isolated, decisions are trivially computable, or information volume is bounded by design.

Decision Boundary

  1. **Is the session deciding under adversary-influenceable information?** If no, standard decision applies. If yes, proceed.
  2. **Is the `information-intake-budget-receipt` defined?** If yes, intake is bounded. If no, overload is unbounded.
  3. **Does `adversarial-flood-detection-signature` show flood patterns?** If yes, apply tighter intake budget. If no, standard intake.
  4. **Conversely, when can a session decide under unbounded information?** Only when the `decision-sufficiency-predicate-receipt` fires (sufficiency achieved), or the decision is strictly reversible and can be revised with more information.

Operational Effect

  1. **Paralysis Prevention:** Intake is bounded, so decisions fire on sufficiency.
  2. **Flood Detection:** Flood patterns trigger stricter intake.
  3. **Sufficiency Predicate:** Decisions proceed when the predicate fires, even without full information.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class OverloadVerdict(Enum):
    NO_ADVERSARIAL_INPUT = auto()
    SUFFICIENT_DECIDE_NOW = auto()
    INTAKE_BUDGET_EXCEEDED = auto()
    FLOOD_DETECTED = auto()

@dataclass(frozen=True)
class DecisionContext:
    decision_id: str
    intake_budget_defined: bool
    information_considered: float
    information_budget: float
    flood_indicators: int
    sufficiency_predicate_met: bool
    decision_reversible: bool

@dataclass(frozen=True)
class OverloadPolicy:
    flood_threshold: int

@dataclass(frozen=True)
class OverloadManifest:
    verdict: OverloadVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_decision(
        cls, ctx: DecisionContext, policy: OverloadPolicy
    ) -> OverloadManifest:
        
        # Gate 1: Sufficiency met
        if ctx.sufficiency_predicate_met:
            digest = cls._hash(json.dumps({
                "decision": ctx.decision_id,
                "sufficiency": True
            }, sort_keys=True))
            return OverloadManifest(
                verdict=OverloadVerdict.SUFFICIENT_DECIDE_NOW,
                directive=f"DECIDE: {ctx.decision_id} sufficient, proceed.",
                manifest_digest=digest
            )

        # Gate 2: Flood detected
        if ctx.flood_indicators >= policy.flood_threshold:
            return OverloadManifest(
                verdict=OverloadVerdict.FLOOD_DETECTED,
                directive=f"FLAG: {ctx.flood_indicators} flood indicators for {ctx.decision_id}.",
                manifest_digest=cls._hash(f"FLOOD:{ctx.decision_id}")
            )

        # Gate 3: Intake budget exceeded
        if ctx.intake_budget_defined and ctx.information_considered > ctx.information_budget:
            return OverloadManifest(
                verdict=OverloadVerdict.INTAKE_BUDGET_EXCEEDED,
                directive=f"HALT: Intake {ctx.information_considered:.0f} > budget {ctx.information_budget:.0f} for {ctx.decision_id}.",
                manifest_digest=cls._hash(f"BUDGET:{ctx.decision_id}")
            )

        # Gate 4: No adverse input signals
        digest = cls._hash(json.dumps({
            "decision": ctx.decision_id,
            "considered": f"{ctx.information_considered:.0f}",
            "budget": f"{ctx.information_budget:.0f}",
            "flood": str(ctx.flood_indicators)
        }, sort_keys=True))
        
        return OverloadManifest(
            verdict=OverloadVerdict.NO_ADVERSARIAL_INPUT,
            directive=f"PROCEED: No overload detected for {ctx.decision_id}.",
            manifest_digest=digest
        )