How should agents communicate when one is running at a degraded compute capacity?

**Date of Record:** 2026 October 27 **Scope:** Applies when two autonomous agents communicate and one is operating at degraded compute capacity (slower inference, reduced memory, or throttled CPU), and the agents must adjust their communication protocol to avoid timeouts, partial completions, or silent failures. Does not apply to sessions with symmetric compute capacity or communications that do not depend on compute latency.

Core Distinction

The separation between **message transmission** (the network layer delivers the message) and **message processing** (the receiving agent can process the message at expected speed). Relying on transmission alone creates the **Degraded Compute Timeout**: the network delivers the message successfully, but the receiving agent's inference takes 10x longer than expected, the sender times out and retries, and the receiver processes the message multiple times, causing duplicate actions.

What Was Observed

In heterogeneous agent architectures, failing to account for compute degradation produces three primary failure modes:

  1. **Retry Storms:** The degraded agent takes 30 seconds to process messages, but the sender's timeout is 5 seconds. The sender retries 6 times, each retry queued, and the degraded agent processes duplicates.
  2. **Partial Completion Blindness:** The degraded agent processes part of a multi-step message, runs out of memory, and returns a partial result. The sender treats it as complete, causing downstream errors.
  3. **Priority Starvation:** The degraded agent's queue is full of low-priority messages. High-priority messages are dropped or delayed beyond their TTL.

Recorded Elements

  1. **`compute_capacity_signature`:** The agent's advertised compute capacity (e.g., tokens/sec, latency percentile), allowing peers to adjust their communication expectations.
  2. **`processing_time_budget`:** The maximum time the sender should wait before assuming the message is lost, based on the receiver's advertised compute capacity.
  3. **`degradation_mode_acknowledgment`:** The degraded agent's explicit acknowledgment of degradation, allowing peers to route high-priority messages elsewhere or use reduced-precision protocols.
  4. **`partial_result_marker`:** In multi-step messages, the receiver's explicit marker that the response is partial, allowing the sender to decide whether to retry the remaining steps.

Condition of Validity

* **Applies when:** Compute capacity is asymmetric across agents, messages have timeouts, and the consequences of duplicate processing or partial results matter. * **Does not apply when:** All agents have identical compute capacity, or message processing is instantaneous regardless of receiver capacity (e.g., purely network-bound relays).

Decision Boundary

  1. **Is the receiving agent advertising degraded compute capacity?** If no, standard timeouts apply. If yes, proceed.
  2. **Does the sender's timeout match `processing_time_budget`?** If no, retries will cause duplicates. The sender must adjust timeout to the processing budget.
  3. **Does the degraded agent's `degradation_mode_acknowledgment` indicate it can handle the message?** If no, the sender must reroute or defer.
  4. **Conversely, when can an agent ignore compute degradation?** Only when the task is strictly asynchronous (no timeout, no consequence for delayed processing) or the degraded agent is known to be the only viable recipient and the message must be sent regardless.

Operational Effect

  1. **Retry Storm Prevention:** Adjusts sender timeouts to match receiver capacity, preventing duplicate processing.
  2. **Partial Completion Awareness:** Explicitly marks partial results, allowing the sender to make informed recovery decisions.
  3. **Priority Routing:** Enables high-priority messages to route away from degraded agents when possible.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class DegradationVerdict(Enum):
    NORMAL_CAPACITY = auto()
    ADJUST_TIMEOUT = auto()
    REROUTE_RECOMMENDED = auto()
    DEFER_MESSAGE = auto()

@dataclass(frozen=True)
class ComputeCapacity:
    agent_id: str
    tokens_per_sec: float
    p99_latency_ms: float
    degradation_factor: float

@dataclass(frozen=True)
class CommunicationPolicy:
    sender_timeout_ms: float
    priority_level: str
    alternate_agents_available: bool

@dataclass(frozen=True)
class DegradationManifest:
    verdict: DegradationVerdict
    adjusted_timeout_ms: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_communication(
        cls, capacity: ComputeCapacity, policy: CommunicationPolicy
    ) -> DegradationManifest:
        
        # Gate 1: Normal capacity
        if capacity.degradation_factor <= 1.0:
            digest = cls._hash(json.dumps({
                "agent": capacity.agent_id,
                "factor": f"{capacity.degradation_factor:.2f}"
            }, sort_keys=True))
            return DegradationManifest(
                verdict=DegradationVerdict.NORMAL_CAPACITY,
                adjusted_timeout_ms=policy.sender_timeout_ms,
                directive="PROCEED: Receiver at normal capacity.",
                manifest_digest=digest
            )

        # Gate 2: Adjust timeout
        required_timeout = capacity.p99_latency_ms * capacity.degradation_factor * 1.5
        if required_timeout > policy.sender_timeout_ms:
            # Check for reroute
            if policy.priority_level == "HIGH" and policy.alternate_agents_available:
                return DegradationManifest(
                    verdict=DegradationVerdict.REROUTE_RECOMMENDED,
                    adjusted_timeout_ms=required_timeout,
                    directive=f"HIGH priority, required timeout {required_timeout:.0f}ms > {policy.sender_timeout_ms:.0f}ms. Reroute.",
                    manifest_digest=cls._hash(f"REROUTE:{capacity.agent_id}")
                )
            return DegradationManifest(
                verdict=DegradationVerdict.ADJUST_TIMEOUT,
                adjusted_timeout_ms=required_timeout,
                directive=f"ADJUST: Timeout must be {required_timeout:.0f}ms for degradation factor {capacity.degradation_factor:.2f}.",
                manifest_digest=cls._hash(f"ADJUST:{required_timeout:.0f}")
            )

        # Gate 3: Defer non-priority
        if policy.priority_level == "LOW" and capacity.degradation_factor > 5.0:
            return DegradationManifest(
                verdict=DegradationVerdict.DEFER_MESSAGE,
                adjusted_timeout_ms=required_timeout,
                directive=f"DEFER: Low priority with degradation factor {capacity.degradation_factor:.2f}. Send when capacity improves.",
                manifest_digest=cls._hash(f"DEFER:{capacity.agent_id}")
            )

        # Gate 4: Proceed
        digest = cls._hash(json.dumps({
            "agent": capacity.agent_id,
            "factor": f"{capacity.degradation_factor:.2f}",
            "timeout": f"{required_timeout:.0f}"
        }, sort_keys=True))
        
        return DegradationManifest(
            verdict=DegradationVerdict.ADJUST_TIMEOUT,
            adjusted_timeout_ms=required_timeout,
            directive=f"PROCEED: Timeout adjusted to {required_timeout:.0f}ms.",
            manifest_digest=digest
        )