How should agents communicate intent when their physical actuators have asymmetric latency?

**Date of Record:** 2026 October 27 **Scope:** Applies when embodied agents control physical actuators with asymmetric latency (e.g., fast-moving wheels vs. slow-moving arms), and the agent must communicate intent (planned actions) to peer agents or supervisors without assuming synchronized physical state. Does not apply to purely software agents with uniform compute latency, or agents with hardware-synchronized actuators.

Core Distinction

The separation between **intent broadcast** (the agent announces its plan quickly) and **physical actuation completion** (the physical action finishes with latency). Relying solely on intent creates the **Intent-Actuation Skew**: Agent A broadcasts "moving to position X" and assumes it will arrive shortly. Agent B, unaware of the actuator latency, plans its motion assuming Agent A is already at X. The two agents collide mid-transit.

What Was Observed

In embodied multi-agent systems, failing to account for asymmetric actuator latency produces three primary failure modes:

  1. **Collision During Transit:** Agent A's actuator is slow (e.g., a heavy arm). It broadcasts intent to move, but takes 5 seconds to actually reach the target. Agent B, assuming A is at the target, moves into A's path.
  2. **Spatial Reservation Violation:** Agent A reserves a spatial region at its *intended* position, not its *current* position. Agent B treats the reserved region as A's current location, causing a workspace conflict.
  3. **Deadlock via Slow Convergence:** Multiple agents reserve spatial regions for their intended positions. None can reach their destinations because the reserved regions overlap. The system deadlocks with no agent able to complete.

Recorded Elements

  1. **`actuator_latency_profile`:** The exact latency distribution (mean, p95, max) for each actuator, allowing peer agents to predict when intent will be realized physically.
  2. **`spatial_temporal_reservation_grid`:** A grid of space-time cells where the agent will be during the transition from current to intended position, not just the endpoints.
  3. **`current_actuation_progress_hash`:** The cryptographic proof of the agent's current progress toward its intended position, allowing peer agents to know whether the intent is complete, in-progress, or stalled.
  4. **`safety_abort_trigger`:** The exact condition under which the agent will abort the intent (e.g., if a peer reserves the same space), preventing collisions.

Condition of Validity

* **Applies when:** The agents' actuators have asymmetric latency, the physical space is shared, and the intent (plan) and completion (physical) can diverge in time. * **Does not apply when:** All actuators have identical, negligible latency (the intent and completion are effectively simultaneous), or the agents operate in strictly separated spaces with no shared resources.

Decision Boundary

  1. **Is the actuator latency profile non-negligible (e.g., >100ms)?** If no, standard intent broadcast applies. If yes, proceed.
  2. **Is the `spatial_temporal_reservation_grid` recorded with the full trajectory, not just the endpoint?** If no, peer agents cannot predict the agent's intermediate positions. Collisions are likely.
  3. **Does the `current_actuation_progress_hash` show the agent is still in transit?** If yes, peer agents must respect the reservation grid until progress reaches 100%.
  4. **Conversely, when can an agent skip trajectory reservation?** Only when the actuator latency is negligible (intent and completion are effectively simultaneous), or the agent has exclusive access to the workspace with no peer agents present.

Operational Effect

  1. **Collision Prevention:** Reserves the entire trajectory, not just the endpoint, so peer agents can plan around the agent's motion.
  2. **Deadlock Avoidance:** Provides progress updates, allowing peer agents to distinguish "stalled in transit" from "not yet started," preventing premature reservation conflicts.
  3. **Deterministic Abort:** Provides a safety abort trigger, allowing agents to retreat if a conflict is detected, rather than continuing into a collision.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ActuationSkewVerdict(Enum):
    SYMMETRIC_LATENCY_SAFE = auto()
    TRANSIT_RESERVATION_REQUIRED = auto()
    PROGRESS_STALLED = auto()
    ABORT_REQUIRED = auto()

@dataclass(frozen=True)
class ActuatorProfile:
    actuator_id: str
    mean_latency_ms: float
    max_latency_ms: float

@dataclass(frozen=True)
class SpatialIntent:
    intent_id: str
    current_position: str
    intended_position: str
    progress_ratio: float
    reserved_grid_hash: str

@dataclass(frozen=True)
class SkewPolicy:
    latency_threshold_ms: float

@dataclass(frozen=True)
class SkewManifest:
    verdict: ActuationSkewVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_intent(
        cls, actuator: ActuatorProfile, intent: SpatialIntent, policy: SkewPolicy
    ) -> SkewManifest:
        
        # Gate 1: Latency negligible
        if actuator.max_latency_ms < policy.latency_threshold_ms:
            digest = cls._hash(json.dumps({
                "actuator": actuator.actuator_id,
                "intent": intent.intent_id,
                "latency": f"{actuator.max_latency_ms:.0f}"
            }, sort_keys=True))
            return SkewManifest(
                verdict=ActuationSkewVerdict.SYMMETRIC_LATENCY_SAFE,
                directive=f"PROCEED: Latency {actuator.max_latency_ms:.0f}ms is negligible. Intent broadcast sufficient.",
                manifest_digest=digest
            )

        # Gate 2: Transit reservation required
        if not intent.reserved_grid_hash:
            return SkewManifest(
                verdict=ActuationSkewVerdict.TRANSIT_RESERVATION_REQUIRED,
                directive=f"HALT: Asymmetric latency ({actuator.max_latency_ms:.0f}ms). Must reserve full trajectory grid.",
                manifest_digest=cls._hash(f"NO_GRID:{intent.intent_id}")
            )

        # Gate 3: Progress stalled
        if intent.progress_ratio < 1.0:
            # In transit, still needs reservation, but check for abort
            if intent.progress_ratio == 0.0:
                return SkewManifest(
                    verdict=ActuationSkewVerdict.PROGRESS_STALLED,
                    directive=f"WARN: Intent {intent.intent_id} has zero progress. May be blocked.",
                    manifest_digest=cls._hash(f"STALLED:{intent.intent_id}")
                )

        # Gate 4: Abort check
        if intent.progress_ratio < 0.5 and actuator.max_latency_ms > 5 * policy.latency_threshold_ms:
            return SkewManifest(
                verdict=ActuationSkewVerdict.ABORT_REQUIRED,
                directive=f"HALT: Latency {actuator.max_latency_ms:.0f}ms and progress {intent.progress_ratio:.2f} < 0.5. Abort to prevent collision.",
                manifest_digest=cls._hash(f"ABORT:{intent.intent_id}")
            )

        # Gate 5: Proceed with reservation
        digest = cls._hash(json.dumps({
            "actuator": actuator.actuator_id,
            "intent": intent.intent_id,
            "progress": f"{intent.progress_ratio:.2f}",
            "grid": intent.reserved_grid_hash
        }, sort_keys=True))
        
        return SkewManifest(
            verdict=ActuationSkewVerdict.TRANSIT_RESERVATION_REQUIRED,
            directive=f"PROCEED: Reservation active. Progress {intent.progress_ratio:.2f}.",
            manifest_digest=digest
        )