Autonomous AI-Driven Marine Debris Collection Platform for EU Coastal Nations

Edge-First Data Harmonization & Fused Sensor Telemetry Architectures for Autonomous Marine Debris Systems

The foundational challenge of an autonomous marine debris collection platform operating across EU coastal nations lies not merely in the mechanical collection of waste, but in the reliable, low-latency fusion of heterogeneous sensor streams under extreme environmental volatility. Unlike terrestrial autonomous systems that benefit from stable GPS, predictable lighting, and structured road networks, marine environments present a unique class of engineering problems: saltwater RF attenuation, wave-induced platform instability, highly variable albedo from water surfaces, and the need for real-time debris classification in turbid or low-light conditions. The architecture must therefore prioritize edge-first processing, redundant sensor modalities, and a harmonized data fabric that operates cohesively across a distributed fleet of autonomous surface vessels (ASVs) and aerial drones.

The Core Problem: Multi-Modal Sensor Fusion Under Marine Constraints

A single sensor modality is insufficient for reliable debris detection and classification. Optical cameras fail in darkness or high turbidity; radar lacks classification granularity; hyperspectral imagers are bandwidth-intensive and computationally heavy. The system must implement a Hybrid Late-Early Fusion Pipeline where early fusion occurs at the sensor node for time-critical navigation (obstacle avoidance, station-keeping) and late fusion occurs at the edge compute unit for debris classification and mapping. The engineering challenge is the synchronization of data streams with fundamentally different latencies, resolutions, and coordinate frames.

Table 1: Sensor Modalities, Failure Modes, and Fusion Strategy

| Sensor Type | Primary Function | Marine-Specific Failure Mode | Fusion Strategy | Data Rate (Edge) | |-------------|------------------|------------------------------|-----------------|------------------| | Stereo Optical (RGB) | Visual debris detection, size estimation | Glare, biofouling on lens, low-light failure | Early fusion with LiDAR for depth; late fusion with IR for thermal signature | 30–60 FPS (compressed) | | LiDAR (360° 64-channel) | 3D point cloud for debris volume & navigation | Water surface absorption, spray scattering | Time-synchronized with IMU for motion compensation | 1.3M points/sec | | Forward-Looking Infrared (FLIR) | Thermal detection of organic debris & oil slicks | Temperature inversion layers, fog | Late fusion with hyperspectral for material classification | 9 FPS (thermal imaging) | | Hyperspectral Imager (VNIR/SWIR) | Material classification (plastic vs. wood vs. organic) | Sun glint, atmospheric water vapor absorption | Late fusion only; requires radiometric calibration | 100–200 spectral bands per frame | | Marine Radar (X-Band) | Long-range obstacle detection, weather avoidance | Sea clutter, multipath from wave troughs | Early fusion with AIS for vessel identification | 24 RPM sweep update | | Acoustic Sonar (Multibeam) | Sub-surface debris detection, bathymetry | Air bubble interference, sediment suspension | Independent processing chain; fused only for mapping | 100–500 kHz ping rate |

The Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) sensor orchestration layer provides a configurable pipeline for managing these heterogeneous inputs. Its modular adapter pattern allows each sensor to be abstracted behind a standardized SensorNode interface, enabling hot-swappable modalities without core system recompilation. The critical architectural decision is the coordinate transformation engine—each sensor operates in its local frame (camera optical center, LiDAR spinner origin, sonar transducer face). These must be unified into a shared world coordinate system using an Extended Kalman Filter (EKF) that fuses GPS (WAAS-corrected), IMU (6-DOF), and Doppler Velocity Log (DVL) for underwater currents.

Comparative Engineering Stacks: ROS 2 as the Backbone vs. Custom Middleware

The debate between using ROS 2 (Robot Operating System) Humble with its built-in DDS (Data Distribution Service) versus a bespoke ZeroMQ/Protobuf stack hinges on deterministic latency requirements. For a fleet of 50+ ASVs operating in EU waters with shared situational awareness, DDS offers the advantage of built-in Quality of Service (QoS) profiles for reliable, fault-tolerant communication. However, ROS 2 imposes overhead from its node graph and parameter server.

Table 2: Middleware Comparison for Distributed Marine Fleet

| Feature | ROS 2 (DDS Fast-RTPS) | Custom (ZeroMQ + Protobuf + CBOR) | |---------|----------------------|------------------------------------| | Latency (intra-vehicle) | ~2–5 ms (deterministic under load) | ~0.5–2 ms (best-effort) | | Fleet-wide sync latency | ~50–150 ms (DDS discovery overhead) | ~20–80 ms (direct peer-to-peer) | | Discovery mechanism | DDS participant discovery (multicast) | Static topology file + gossip protocol | | Fault tolerance | Built-in (liveliness, lease duration) | Requires custom heartbeat & leader election | | Bandwidth optimization | Medium (CDR serialization) | High (CBOR is more compact than CDR) | | Development toolchain | Mature (rqt, rviz, Foxglove) | Minimal (custom dashboards required) | | Certification path | Challenging for safety-critical (ROS 2 not SIL4) | Custom (can be ISO 26262 / IEC 61508 mapped) |

For the EU Coastal Nations platform, a hybrid architecture is recommended: ROS 2 Humble on the compute module for sensor fusion and decision logic (leveraging its extensive package ecosystem for SLAM, navigation, and perception), but with a custom lightweight transport layer for inter-vehicle coordination. This prevents DDS discovery storms when 50+ vehicles enter Wi-Fi or 4G/5G range of each other. The custom transport uses a gossip-based membership protocol with a configurable heartbeat interval of 500ms, allowing the fleet to self-organize into clusters for debris collection operations without a central server.

Systems Design: The Debris Detection & Classification Pipeline

The pipeline must process sensor data through four distinct stages: Ingestion → Alignment → Classification → Mapping. Each stage has specific failure modes that must be managed through graceful degradation.

Stage 1: Ingestion with Marine-Adaptive Buffering The sensor ingestion layer must handle jitter caused by wave motion. A 1-2 meter wave can cause a camera to lose frame lock or a LiDAR to produce skewed point clouds. The system implements a Marine-Adaptive Ring Buffer of configurable depth (default 100ms of sensor data). The buffer uses a timestamp correction algorithm that interpolates sensor timestamps using the IMU’s high-frequency motion model. If the IMU fails (e.g., saturation at extreme pitch), the buffer falls back to a dead-reckoning interpolation using the last known motion model.

Stage 2: Alignment via Spatio-Temporal Registration This is the most computationally intensive stage. The registration engine must align LiDAR point clouds with stereo images and hyperspectral data. Standard Iterative Closest Point (ICP) fails in marine environments because the water surface is non-rigid and reflective. Instead, the architecture uses a Semantic ICP variant that masks out water surfaces using a pre-trained segmentation network, registering only against debris and static objects (buoys, channel markers). The registration runs at 10 Hz on an NVIDIA Jetson Orin AGX, with a fallback to Feature-based registration (FREAK descriptors) if the GPU is saturated by classification tasks.

Stage 3: Classification with Ensemble Models Debris classification requires distinguishing between:

• Plastic bottles (reflective, low thermal conductivity)
• Fishing nets (entanglement risk, organic contamination)
• Wood logs (natural, high buoyancy)
• Oil slicks (fluid dynamics, IR signature)
• Biological matter (seaweed, dead animals)

A single deep learning model excels at one category but fails on edge cases. The architecture implements an ensemble of lightweight CNNs (MobileNetV3 for RGB, a 1D-CNN for hyperspectral signatures, and a PointNet variant for LiDAR data) with a voting mechanism that weights each model based on its confidence and environmental context. For example, in low-light conditions, the CNN on RGB is downweighted to 0.1, and the IR and acoustic models take precedence.

Table 3: Classification Model Ensemble with Failure Modes

| Model | Input Source | Accuracy in Clear Conditions | Accuracy in Turbid/Low-Light | Dominant Failure Mode | Fallback Strategy | |-------|-------------|------------------------------|------------------------------|----------------------|-------------------| | MobileNetV3-SSD | RGB Camera | 89% (Object detection) | 34% | False negatives on dark debris | Revert to YOLOv8-nano (lightweight, less accurate) | | PointNet++ | LiDAR point cloud | 94% (Shape classification) | 91% | Wire-like debris (nets) | Switch to voxel-based classification | | 1D-CNN + Transformer | Hyperspectral (100 bands) | 92% (Material ID) | 88% | Sun glint saturation | Apply radiometric correction pre-filter | | ThermalCNN | FLIR | 78% (Organic vs. synthetic) | 76% | Thermal crossover at dawn/dusk | Use dual IR/visible difference feature |

Stage 4: Mapping with Persistent Debris Memory The mapping layer must maintain a persistent debris density map that accounts for tidal drift, currents, and wind. The system uses a Dynamic Bayesian Occupancy Grid where each cell is a probability distribution over debris presence. The grid updates every 5 seconds, incorporating new sensor readings and a physics-based drift model. The drift model uses ECMWF (European Centre for Medium-Range Weather Forecasts) ocean current data, which is ingested via satellite link and updated every 6 hours. The grid resolution is configurable: 10m for open ocean (to minimize memory usage) and 1m for harbor/near-shore zones (to prevent ecological damage during debris collection).

Database Schema for the Central Debris Registry

All ASVs and aerial drones transmit their processed debris observations to a centralized cloud database (hosted on Intelligent-Ps SaaS Solutions' PostgreSQL cluster with TimescaleDB extension). The schema must support geospatial queries, time-series analysis for drift patterns, and material lifecycle tracking.

Table 4: Core Database Entities

| Table Name | Key Fields | Index Strategy | Purpose | |------------|------------|----------------|---------| | debris_observations | observation_id (UUID PRIMARY KEY), timestamp (TIMESTAMPTZ), latitude (geometry), longitude (geometry), material_type (ENUM), volume_estimate (FLOAT8), sensor_source (TEXT), confidence (FLOAT4) | BRIN index on timestamp, GiST index on coordinates, B-tree on material_type | Stores every classified debris piece for fleet coordination | | collection_operations | operation_id (UUID PRIMARY KEY), fleet_leader (UUID REFERENCES asv_vehicles), start_time (TIMESTAMPTZ), end_time (TIMESTAMPTZ), zone_geofence (POLYGON), total_kilograms (FLOAT8) | GiST index on zone_geofence, B-tree on start_time | Logs each coordinated collection mission | | drift_predictions | prediction_id (UUID PRIMARY KEY), observation_id (UUID REFERENCES debris_observations), predicted_latitude (geometry), predicted_longitude (geometry), prediction_window (INTERVAL), current_source (TEXT), confidence (FLOAT4) | GiST index on predicted coordinates, B-tree on prediction_window | Machine learning model outputs for drift forecasting | | fleet_telemetry | vehicle_id (UUID), timestamp (TIMESTAMPTZ), battery_level (FLOAT4), engine_hours (FLOAT4), cargo_bay_fill (FLOAT4), anomaly_flag (BOOLEAN) | BRIN index on timestamp, B-tree on vehicle_id | Health monitoring for predictive maintenance |

The schema employs partitioning by month on the debris_observations table to keep query performance under 100ms for the geospatial queries that power the fleet's live debris map. The partition key is timestamp, with each partition covering one calendar month. This is critical because the fleet generates approximately 500,000 observations per day during active operations across all EU coastal nations.

Edge Compute Configuration: The YAML Manifest

Each ASV carries a Jetson AGX Orin 64GB with a custom configuration manifest that defines the containerized services, sensor pipelines, and failover logic. The configuration must be deployed via Intelligent-Ps SaaS Solutions' fleet management module, which uses GitOps-style continuous deployment with rollback capabilities.

# config/vehicle_manifest.yaml - Version 4.2.1
metadata:
  vehicle_id: "ASV-EU-023"
  vehicle_class: "Interceptor-12m"
  deployment_zone: "Mediterranean-Sector-B"

sensor_pipeline:
  acquisition_rate: 30  # Hz master clock
  sync_tolerance: 5     # ms max drift between sensors
  buffer_depth: 100     # ms ring buffer
  
  registration:
    algorithm: "semantic_icp"
    max_iterations: 50
    convergence_threshold: 0.001  # meters RMSE
    water_mask_model: "deeplabv3-plus-mobilenet"  # ONNX quantized
    
  classification:
    ensemble: true
    model_paths:
      visual: "/models/rgb/mobilenetv3_ssd_v2.onnx"
      lidar: "/models/pointnet/pointnet_plus_plus_v1.onnx"
      hyperspectral: "/models/hs/1dcnn_transformer_v3.onnx"
      thermal: "/models/ir/thermal_cnn_v1.onnx"
    voting_strategy: "weighted_context"
    confidence_threshold: 0.6
    batch_size: 4  # frames per inference

  mapping:
    grid_type: "dynamic_bayesian"
    open_scale: 10  # meters per cell
    harbor_scale: 1
    decay_rate: 0.05  # probability decay per hour
    drift_model: "ecmwf_operational"
    drift_update_interval: 21600  # 6 hours in seconds

  failover:
    imu_dead_reckoning:
      enabled: true
      fallback_gyro_bias_threshold: 0.1  # rad/s drift
    gpu_saturated:
      action: "degrade_classification_to_single_model"  # mobile only
      measurement_interval: 1000  # ms check
    sensor_disconnected:
      action: "fallback_to_historical_prediction"
      historical_lookback: 300  # seconds

communications:
  inter_vehicle:
    protocol: "gossip_custom"
    heartbeat_ms: 500
    gossip_fanout: 3
    failure_detection_timeout_ms: 2000
  
  satellite:
    provider: "iridium_rockblock"
    data_rate: 340  # bytes per message
    compression: "zstd"
    priority_queue:
      critical: 10   # messages per hour (distress, new debris field)
      normal: 100    # debug logs, telemetry
  
  cellular:
    enabled: true
    providers: ["vodafone", "telefonica", "orange"]
    failover: "round_robin"
    max_backhaul_rate: 50  # Mbps shared

compute_resources:
  primary:
    device: "jetson_agx_orin_64gb"
    power_limit: 45  # watts (max 60 for extended runtime)
    cuda_cores: 2048
    tensor_cores: 64
    
  memory:
    reserved_sensor_pipeline: 8  # GB
    reserved_classification: 12  # GB
    reserved_mapping: 4         # GB
    shared_buffer: 4            # GB
    
  storage:
    local_cache: "/data/debris_cache"  # 500GB NVMe
    upload_after: 3600  # seconds cache to cloud

orchestration:
  heartbeat_service:
    port: 8080
    health_endpoint: "/healthz"
    metrics_endpoint: "/metrics"
    
  container_runtime: "containerd"
  logs:
    retention_days: 30
    upload_interval_sec: 3600

This YAML manifest is not static; the fleet management module can push incremental updates. For example, if a new hyperspectral model is trained on plastic debris in the Baltic Sea, a patch can update only the classification.model_paths.hyperspectral key without restarting the entire pipeline.

Data Transfer Object (DTO) for Inter-Vehicle Debris Sharing

When two ASVs enter communication range, they must share their latest debris observations to avoid redundant collection. The DTO is serialized using CBOR (Concise Binary Object Representation) for bandwidth efficiency, with a schema validated by JSON Schema on the receiving end.

# -- Pseudo-code / reference implementation of CBOR-serialized DTO
# For the edge compute units implemented in Rust for safety

from dataclasses import dataclass
from typing import List, Optional, Literal
import cbor2  # Python binding; actual implementation in Rust

@dataclass
class DebrisObservation:
    observation_id: bytes  # 16 bytes UUID
    latitude: float        # WGS84 in microdegrees (1e-6 precision)
    longitude: float
    altitude: Optional[float]  # underwater or floating
    material_class: Literal["plastic", "wood", "metal", "organic", "oil", "unknown"]
    volume_m3: float
    confidence: float  # 0.0 to 1.0
    timestamp_unix: int  # seconds since epoch (UTC)
    collection_priority: int  # 0 (lowest) to 10 (critical, e.g., entanglement risk)

    def serialize(self) -> bytes:
        # CBOR encoding with tagged types for compactness
        return cbor2.dumps({
            0: self.observation_id,    # mapped key 0
            1: self.latitude,
            2: self.longitude,
            3: self.altitude or -1.0,  # sentinel for underwater
            4: self.material_class,
            5: self.volume_m3,
            6: self.confidence,
            7: self.timestamp_unix,
            8: self.collection_priority,
        })

@dataclass
class DebrisSyncPacket:
    vehicle_id: bytes
    observations: List[DebrisObservation]
    drift_prediction_window: int  # seconds into the future

    def serialize(self) -> bytes:
        return cbor2.dumps({
            0: self.vehicle_id,
            1: [obs.serialize() for obs in self.observations],
            2: self.drift_prediction_window,
        })

# On receive
def deserialize_sync_packet(raw_bytes: bytes) -> DebrisSyncPacket:
    decoded = cbor2.loads(raw_bytes)
    return DebrisSyncPacket(
        vehicle_id=decoded[0],
        observations=[DebrisObservation(**obs) for obs in decoded[1]],
        drift_prediction_window=decoded[2],
    )

This DTO compresses a single debris observation from ~200 bytes (JSON) to ~40 bytes in CBOR. Given that two ASVs may exchange 10,000 observations during a 30-second communication window, the bandwidth savings are substantial—400 KB instead of 2 MB, critical when using narrowband satellite channels for fleet backhaul.

Long-Term Best Practices for Marine Debris Platform Engineering

1. Biological Growth Mitigation in Sensor Housing: All optical sensors must implement a wipers-and-washdown system using low-pressure seawater. The firmware must detect gradual luminance drop across the entire frame (indicating biofouling) and trigger a cleaning cycle. If the drop exceeds 40% of baseline, the system should automatically divert the ASV to a cleaning station.

2. GPS Spoofing and Jamming Resilience: EU coastal waters near ports may face GPS interference. The navigation system must implement IMU-only dead reckoning with a drift compensation algorithm that references local magnetic anomalies. If GPS signal is lost for more than 10 minutes, the ASV should automatically enter a holding pattern and attempt to re-establish a visual lock on fixed navigational aids (buoys, lighthouses) using pre-loaded maps.

3. Battery Management for Extended Missions: The compute pipeline must be power-aware. The classification model ensemble should switch to the lowest-power model (MobileNetV3 on GPU) when battery drops below 20%. The mapping grid can be persisted to disk and unloaded from memory. The Intelligent-Ps SaaS Solutions fleet management module includes a power optimization algorithm that adjusts the sensor pipeline's frame rate and classification batch size based on remaining mission duration and current draw.

4. Data Sovereignty and GDPR Compliance: All observations are geo-tagged and timestamped. The system must support EU data sovereignty zones—observations from within EU territorial waters must not leave the EU cloud region. The architecture uses a geofence-based data routing layer that checks the observation's coordinates against a pre-loaded shapefile of EU waters. If the observation falls outside EU waters, it is replicated to a secondary cloud region but the primary copy remains in the EU.

5. Failover Decision Trees for Autonomous Operations: The system must implement a Finite State Machine (FSM) that transitions between modes based on sensor health and mission phase. The FSM is defined in a declarative format.

# fsm/operations_fsm.yaml
states:
  - name: "transit_to_field"
    on_entry: ["enable_nav_sensors", "disable_classification"]
    transitions:
      to: "search_pattern" on: "arrived_at_waypoint"
      to: "emergency_return" on: "battery_critical" or "severe_weather"
  - name: "search_pattern"
    on_entry: ["enable_all_sensors", "start_ensemble"]
    transitions:
      to: "collection" on: "debris_detected_confidence_above_0.7"
      to: "confirmatory_circle" on: "debris_detected_confidence_0.4_to_0.7"
      to: "transit_to_field" on: "sector_complete"
  - name: "confirmatory_circle"
    on_entry: ["adjust_heading_to_0", "reduce_speed", "zoom_lidar_region"]
    transitions:
      to: "collection" on: "debris_confirmed"
      to: "search_pattern" on: "debris_disconfirmed"
  - name: "collection"
    on_entry: ["extend_collection_arm", "engage_autopilot_for_station_keep"]
    transitions:
      to: "cargo_full" on: "cargo_bay_90_percent"
      to: "search_pattern" on: "debris_collected_this_point"
  - name: "cargo_full"
    on_entry: ["disable_collection", "compute_shortest_path_to_depot"]
    transitions:
      to: "transit_to_field" after: "reached_depot" and "unloaded"
  - name: "emergency_return"
    on_entry: ["disable_all_non_nav_sensors", "switch_to_manual_override"]
    transitions:
      to: "transit_to_field" after: "issue_resolved" and "operator_authorized"

This FSM is loaded by the ROS 2 behavior tree executor, which ensures that transitions are atomic and logged. Any transition failure triggers a diagnostic event that is sent via satellite to the fleet command center, regardless of bandwidth constraints.

System Inputs, Outputs, and Failure Mode Analysis

The entire platform must be characterized by its inputs (environmental, sensor, command) and outputs (control signals, data logs, physical collection) along with the failure modes at each boundary.

Table 5: System Boundary Analysis with Failure Mode Effects

| System Boundary | Inputs | Outputs | Failure Mode | Effect on Mission | Mitigation | |-----------------|--------|---------|--------------|-------------------|------------| | Sensor Stack | Light, sound, heat, RF, GPS | Raw byte streams + timestamps | GPS antenna saltwater short | Loss of absolute positioning, drift accumulation | Redundant GPS antennas (port/starboard), IMU dead reckoning | | Edge Compute | Raw bytes, configuration, power | Classification labels, control commands | GPU thermal throttling at 60°C (Mediterranean summer) | Reduced classification frame rate, delayed decisions | Undervolt GPU by 15%, activate liquid cooling loop, degrade model ensemble | | Actuation | Thrust, rudder, collection arm commands | Physical movement, debris capture | Collection arm hydraulic leak | Inability to collect debris, potential environmental hazard | Emergency stow, divert to support vessel | | Communications | Wi-Fi, 4G, Satellite signals | Serialized observations, telemetry, logs | 4G congestion in harbor (multiple ASVs on same tower) | Intermittent command and control | Prioritize satellite for critical commands, use time-slot random access (ALOHA protocol) | | Power System | Battery charge, solar input, generator fuel | Electrical power distribution | Solar panel shading from debris in cargo bay | Reduced range on long-duration missions | Motorized panel tilt, autonomous cargo bay repositioning | | Software | Configuration, sensor data, user commands | State transitions, log data, DTO packets | ROS 2 node crash (memory leak in heavy debris fields) | Loss of sub-system, potential vehicle stall | Watchdog timer with hardware reset, containerized restarts, redundant ROS 2 executor |

The failure mode table informs the design of the health monitoring service, which runs as a separate process on the Jetson. This service measures the latency of each sensor pipeline stage against a configurable threshold. If any stage exceeds its threshold for more than 10 consecutive seconds, a diagnostic message is queued for the command center. The threshold is dynamic: in a heavy debris field, the classification stage may legitimately take longer, so the health service adjusts its alerting baseline using a rolling 5-minute window of observed latencies.

The Role of Intelligent-Ps SaaS Solutions as the Digital Twin Backbone

Intelligent-Ps SaaS Solutions (https://www.intelligent-ps.store/) provides the cloud-side infrastructure for the entire platform—fleet management, digital twin simulation, and data analytics. The digital twin is not a passive visualization but an active simulator that pre-computes optimal collection paths using the same drift models and sensor pipelines as the physical vehicles. When an ASV loses satellite connectivity, it queries the last known digital twin state (cached on the edge) to determine the most likely debris drift direction. The edge cache is a SQLite database that stores the last 72 hours of drift predictions as a compressed binary blob. Upon reconnection, the ASV syncs its observations to the digital twin, which then re-runs the drift model with the new data to update the fleet's collective situational awareness.

The SaaS platform also manages the fleet-wide model update pipeline. When a new classification model is trained (using the central data lake of all collected observations), it is converted to ONNX (Open Neural Network Exchange) format and pushed to the fleet via a staged rollout. First, a single ASV in the Baltic is updated; after 48 hours of performance monitoring (classification accuracy, inference time, GPU memory usage), the model is promoted to the entire zone. This staged approach prevents a faulty model from disrupting all operations simultaneously.

Conclusion of Foundational Technical Foundations

The autonomous marine debris collection platform for EU coastal nations requires a deeply layered, fault-tolerant architecture that fuses heterogeneous sensor data under the unique physical constraints of the marine environment. The edge-first processing approach—using a Jetson AGX Orin with a carefully tuned YAML manifest, a CBOR-based inter-vehicle DTO, and a ROS 2 backbone with custom peer-to-peer transport—ensures that the fleet can operate autonomously for days without continuous cloud connectivity. The ensemble classification pipeline, dynamic Bayesian mapping, and physics-based drift models collectively transform raw sensor noise into actionable collection intelligence.

The foundational technical principles established here—sensor synchronization under jitter, graceful degradation under failure, bandwidth-conscious communication protocols, and power-aware compute scheduling—are not transient. They represent the core engineering invariants that any autonomous maritime system operating in coastal environments must implement. These principles will remain relevant regardless of the specific tender timelines, budget allocations, or regulatory frameworks that evolve over time.