---
title: Underwater Robot Self-Organizing Autonomy (UROSA)
url: https://www.emergentmind.com/topics/underwater-robot-self-organizing-autonomy-urosa
type: topic
---

# Underwater Robot Self-Organizing Autonomy (UROSA)

Underwater Robot Self-Organizing Autonomy (UROSA) denotes a family of underwater autonomy formulations centered on robots that reason, adapt, and reorganize behavior under marine conditions marked by limited visibility, unpredictable currents, and communication constraints. In the recent literature, the term is used in closely related but non-identical ways: as a distributed cognitive architecture built from Agentic ROS 2 Nodes for Autonomous Underwater Vehicles [2507.23735], as a knowledge-graph- and retrieval-augmented framework for multi-agent autonomy and shared autonomy in underwater missions [2507.20370], and as a set of core tenets—unified pipeline, reactive control, and self-organization—instantiated in autonomous underwater manipulation by AquaBot [2410.18969]. This suggests that UROSA is best understood not as a single algorithm, but as an autonomy paradigm spanning symbolic grounding, distributed coordination, closed-loop control, and online adaptation.

## 1. Conceptual framing and research usage

Within the cited work, UROSA is consistently associated with advanced autonomy in environments where conventional rule-based or heavily teleoperated operation is difficult to sustain. One formulation emphasizes that multiple robotic agents operate independently while remaining connected to a human supervisor, with a RAG-powered large language model augmented by knowledge graph data and domain taxonomy to support autonomous multi-agent decision-making and human-robot interaction [2507.20370]. Another formulation defines UROSA as an architecture that decentralises cognition into specialised AI agents responsible for multimodal perception, adaptive reasoning, dynamic mission planning, and real-time decision-making [2507.23735]. In AquaBot, UROSA is articulated through three core tenets: a unified pipeline in which perception, planning, control, and learning are encapsulated in a single visuomotor policy $\pi_\theta$, reactive control via short-horizon execution and 10 Hz replanning, and self-organization through autonomous data collection and speed-parameter reorganization [2410.18969].

A common misconception is to equate self-organizing autonomy with the absence of operator involvement. The literature does not support that interpretation. In the shared-autonomy formulation, human oversight is explicit, version-tagged, auditable, and invoked when confidence falls below threshold or when KG queries fail [2507.20370]. Another misconception is to treat UROSA as synonymous with LLM-based planning alone. AquaBot demonstrates a realization of UROSA principles using behavior cloning, closed-loop visuomotor control, and surrogate-based online optimization rather than an LLM-centric stack [2410.18969].

## 2. Architectural forms in underwater systems

In the multi-agent shared-autonomy formulation, agents $A=\{\alpha,\beta,\gamma,\ldots\}$ form a peer-to-peer mesh within acoustic/optical range and fall back to a docking-station hub when out of direct line-of-sight. Near-range exchange uses Visual-Light Communication (VLC), whereas long-range and human links use acoustic modems or docking-station Wi-Fi. Each agent maintains a Local Knowledge Graph mirror synchronized via $\delta$-window updates and a Behavior-Tree stack controlled by an onboard LLM+RAG node. Roles are differentiated as Explorer, Inspector/Manipulator, and optional Relay/Gateway, and every agent executes the same operational cycle: sense via IMU, DVL, and camera; update runtime state $S_i(t)$; query KG and taxonomy via RAG to decide the next BT actions; and communicate observations and bids to neighbors [2507.20370].

The distributed cognitive architecture described in the ROS 2 formulation replaces a single “brain” with Agentic ROS 2 Nodes, each coupling an AI Reasoner, a Safety Parser, and native ROS 2 interfaces. Mission execution is organized around two parallel loops. In the real-world loop, low-level controller nodes subscribe to high-rate control commands, sensors publish raw data on ROS 2 topics, a Specialist Perception Agent publishes fused scene estimates, a Motion Planning Agent outputs trajectories, and a Commander Agent decomposes the high-level mission into sub-tasks and assigns them to specialists. In the digital-twin loop, a Digital Twin Curator Agent consumes sensor streams and meta-data and issues “FidelityInjection” updates to the Simulator, whose Virtual State topic is fused with real state for predictive analyses [2507.23735].

AquaBot represents a task-level embodiment of UROSA for underwater manipulation. Its hardware stack consists of a QYSEA FIFISH V-EVO ROV with six thrusters for 6 DoF force/torque control, an external parallel-jaw gripper, two onboard RGB cameras with 100 ms latency, two fixed external cameras for global 6 DoF pose via stereo, and a tethered control box running a 100 Hz control loop. Its software stack combines two CNN-based visual encoders with ResNet-18 backbones and spatial softmax, an end-to-end MLP policy, a Behavior Cloning module, a Self-Learning module, external-camera-plus-IMU localization and reset, and ROS-style nodes coordinating data flow and automatic resets [2410.18969]. The architectural commonality across these systems is the integration of perception, decision, and actuation within a closed autonomy loop, but the organizational scale ranges from single-robot visuomotor control to distributed multi-robot mission execution.

## 3. Knowledge representation, retrieval, and grounded reasoning

A central UROSA theme is explicit grounding of decisions in structured knowledge. In the shared-autonomy framework, the knowledge graph is defined as $G=(V,E,R)$, where $V$ is partitioned into node types including Agents, Sensors, Capabilities, Objects, TerrainFeatures, and Actions, and $R$ is a finite set of relation-types:
\[
\{\text{hasSensor, canPerform, observes, connected\_to, composed\_of, communicates\_with, adjacent\_to}\}.
\]
The graph is encoded by a binary third-order adjacency tensor $A\in\{0,1\}^{|V|\times|R|\times|V|}$ with entries
\[
A_{i,k,j}=
\begin{cases}
1 & \text{if }(v_i,r_k,v_j)\in E,\\
0 & \text{otherwise.}
\end{cases}
\]
Equivalent incidence matrices $E^{(k)}\in\{0,1\}^{|V|\times|V|}$ are defined for each relation $r_k\in R$. Sample edge instances include $(\alpha,\text{hasSensor},\text{StereoCamera})$, $(\text{Cylinder},\text{composed\_of},\text{Primitive: circle + height})$, $(o_i,\text{affords},\text{Mnp})$, $(\alpha,\text{communicates\_with},\beta)$, and $(\text{RockPatch},\text{adjacent\_to},\text{Trench})$ [2507.20370].

Retrieval-Augmented Generation is used to expose this structured state to the decision module. Given a query $q$ and document set $D$, retrieval is defined as
\[
R(q,D)=\arg\max_{d\in D}\;\mathrm{score}(q,d),
\]
with a score that combines semantic similarity, KG matching, and document frequency through $\lambda_{sem}$, $\lambda_{str}$, and $\lambda_{freq}$. Prompt construction proceeds in three steps: retrieval of a context subgraph $S_{\text{sub}}$ up to depth 2; retrieval of taxonomy fragments $T_{\text{sub}}$; and assembly of a prompt containing runtime state $\{ \text{battery, pose, objectives} \}$, KG triples $\{S_{\text{sub}}\}$, taxonomy rules $\{T_{\text{sub}}\}$, and the question asking for the next action. Candidate action probabilities are then formed by combining the LLM’s language prior $K$ and the retrieved context $C$:
\[
P(a\mid s,K,C)\propto \exp\bigl(\lambda_K \ln P_K(a\mid s)+\lambda_C \ln P_C(a\mid s,C)\bigr),
\]
with $\lambda_C\gg \lambda_K$ enforcing grounding [2507.20370].

The ROS 2 distributed-agent formulation uses a different but related substrate: RAG over a distributed Vector Database. Documents and queries are embedded by an encoder $E(\cdot)$, scored by cosine similarity, and the top-$K$ documents are prepended to the LLM prompt after a SYSTEM specification and current CONTEXT. The cited safety interpretation is that RAG-based contextual grounding limits hallucinations, while the specialized prompt constitution constrains behavior at generation time [2507.23735]. Taken together, these systems show two compatible grounding strategies within UROSA: symbolic graph-and-taxonomy retrieval for capability- and relation-aware reasoning, and vector-database retrieval for contextual recall across distributed cognitive agents.

## 4. Self-organization, planning, and online adaptation

In the multi-agent mission setting, self-organization is implemented explicitly through task allocation and consensus. The task-allocation procedure broadcasts `CALL_FOR_BIDS(t)`, waits $\Delta t_{\text{bid}}$, collects bids $b_i=U_i(t)$, selects the winner $w=\arg\max_i b_i$, assigns the task, and notifies all agents. The utility of a prospective action is
\[
U_i(a\mid s)=w_{\mathrm{eff}}\,E[\mathrm{InfoGain}(a\mid s)]-w_{\mathrm{time}}\,T(a\mid s)-w_{\mathrm{energy}}\,E_{\mathrm{cost}}(a\mid s),
\]
where $\mathrm{InfoGain}$ may be reduction in map uncertainty, $T$ is time-to-complete, and $E_{\mathrm{cost}}$ is energy consumption. Consensus on assignments is obtained by exchanging local estimates $x_j$ and iterating
\[
x_i^{(k+1)}=x_i^{(k)}+\eta\sum_{j\in\mathcal{N}_i}\bigl(x_j^{(k)}-x_i^{(k)}\bigr).
\]
Environmental dynamics are incorporated by re-weighting utility through functions of current strength $c(t)$, visibility $v(t)$, and communication quality $\delta(t)$:
\[
U_i'(a\mid s,e)=U_i(a\mid s)\times f_c(c)\times f_v(v)\times f_\delta(\delta),
\]
with the example penalty $f_c(c)=\exp(-|c-c_0|/\tau_c)$ for strong currents [2507.20370].

In the distributed-agent ROS 2 architecture, mission planning is cast as an MDP, or as a POMDP under partial observations, with state space $S$, action space $A$, transition model $P(s'\mid s,a)$, and reward function $R(s,a)$. Once the Commander Agent issues a sub-goal, the Motion Planning Agent solves for
\[
\pi^*=\arg\max_\pi E_{s_0\sim \mathrm{Init}}\Bigl[\sum_{t=0}^{T}\gamma^t R(s_t,a_t)\Bigr]
\]
subject to dynamic and collision constraints. The implementation is a hybrid solver: high-level discrete planning via A* with heuristic $h(s)$, and low-level trajectory smoothing via CHOMP or RRT*. Continuous control refinement is handled by PPO, with state
\[
s_t=[\text{pose, vel, fused scene features, VDB context embedding}],
\]
continuous actions as thrust commands or waypoint offsets, and reward
\[
r_t=\alpha_1\,\Delta d_t-\alpha_2\,\|a_t\|^2-\alpha_3\,U(s_t),
\]
where $\Delta d_t$ is progress toward a sub-goal and $U(s_t)$ is a model uncertainty metric [2507.23735].

AquaBot realizes self-organization at the level of policy adaptation. Behavior cloning uses demonstrations
\[
D=\{(I^{1:2}_{t,k},a_{t,k})\}
\]
and minimizes
\[
\mathcal{L}_{BC}(\theta)=\mathbb{E}_{(I,a)\sim D}\Bigl\|a-\pi_\theta\bigl(f(I^1),g(I^2)\bigr)\Bigr\|_2^2.
\]
Each action $a\in\mathbb{R}^8$ encodes $(F_x,F_y,F_z,\tau_x,\tau_y,\tau_z,\text{gripper\_open},\text{gripper\_close})$. Self-learning then optimizes a time-invariant speed-scaling parameter $\delta\in[0.5,3]^5$ to maximize $r(\delta)=-T(\delta)$:
\[
\delta^*=\arg\max_{\delta\in[0.5,3]^5} r(\delta)=\arg\min_\delta T(\delta).
\]
A surrogate model $\hat r_\phi$ is iteratively updated by minimizing
\[
\mathcal{L}_{\rm Surr}(\phi)=\mathbb{E}_{(\delta,r)\sim S}\bigl[(\hat r_\phi(\delta)-r)^2\bigr].
\]
The manipulation policy sidesteps explicit hydrodynamic modeling through closed-loop visuomotor control, short action horizons of 1–2 steps, and replanning every 100 ms [2410.18969]. This suggests that UROSA self-organization spans both distributed multi-agent coordination and single-agent self-optimization under real-world dynamics.

## 5. Shared autonomy, safety, and runtime extensibility

Shared autonomy is formalized in the human-intervention protocol of the multi-agent framework. Agents continuously monitor action confidence $\mathrm{conf}(a)$. If $\mathrm{conf}(a)<\theta_{\text{request}}$ or a KG query fails, the agent issues `HITL_Request` to a human via the docking station. The human reviews the suggested context, KG triples, and proposed BT branch, then returns `APPROVE` or `REVISE` within $T_{\max}$. The agent locks the BT until the human decision arrives or a fallback policy triggers safe-hold. In parallel, agents stream telemetry—pose, battery, and current map—at $f=1\ \mathrm{Hz}$ to a GUI, and all KG updates, whether human or automated, are version-tagged and auditable. Mission-level assurance is expressed through `ValidationSuccess`, which is 1 if for all actions in the BT the capability checks `KG.canPerform(a)` pass, and `Completeness`, defined as executed BT nodes divided by planned BT nodes [2507.20370].

The ROS 2 formulation adds a three-tiered safety architecture. First, proactive behavioural scaffolding uses the SYSTEM prompt to enforce strict output grammar. Second, RAG-based contextual grounding limits hallucinations. Third, a reactive Safety Parser validates syntax and value ranges before any ROS 2 publish. This architecture is also extended to runtime functional extensibility through autonomous on-the-fly ROS 2 node generation. A Code-Synthesis Agent receives a natural-language specification, instantiates a code template for a ROS 2 Python package including `package.xml`, `setup.py`, node and test files, encodes safety constraints such as `max_depth ≤ D_max` and `thrust ≤ T_max` in unit tests, and only launches the new node after successful testing [2507.23735].

AquaBot adds a complementary safety pattern at the embodied control level: automated reset and success-detection loops. The external cameras and onboard IMU/compass form a global localization and control loop that enables resets and success detection without human intervention, while the report explicitly notes that self-learning depends on reliable success detection and that the current surrogate optimization scales only speed parameters, leaving more complex policy finetuning to future work [2410.18969]. Across these formulations, UROSA does not eliminate safety supervision; it redistributes it across prompt constraints, retrieval grounding, parsers, BT validation, and human escalation.

## 6. Empirical performance, ablations, and limitations

The strongest direct evidence for KG- and taxonomy-grounded UROSA is the 20-runs-per-condition evaluation of the shared-autonomy framework. The full configuration, `RAG+KG+Taxonomy`, achieved `Mission Success Rate = 100%`, `Avg. Decision Latency ≈ 0.52 s per BT update`, `Communication Overhead ≈ 5 KB per task negotiation`, and `Hallucination Rate ≈ 0%`. The `RAG+KG only` condition achieved `Success 85%`, `Latency ≈ 0.67 s`, `Overhead ≈ 4 KB`, and `Hallucination Rate ≈ 30%`. The `RAG only (no KG/Tax)` condition achieved `Success 21%`, `Latency ≈ 0.48 s`, `Overhead ≈ 3 KB`, and `Hallucination Rate ≈ 75%`. The same system reported `100%` on both mission validation and behavior completeness. Ablation analysis attributed degradation to specific grounding losses: removing the KG caused capability mismatches such as planning manipulation without a manipulator, while removing the taxonomy led to semantically invalid action-object pairs; both removals dramatically increased hallucinations and reduced BT coherence [2507.20370].

The distributed-agent ROS 2 implementation reported a broader set of cognitive-autonomy evaluations. In constrained multi-robot coordination versus A*, the five missions yielded error deltas of `2.56`, `3.78`, `4.23`, `6.37`, and `4.68 m`, with corresponding success rates of `80`, `80`, `80`, `60`, and `60 %`. In UVMS manipulation, the AI Agent had `Planning Time 1.3 s`, `Interp. Success 90 %`, and `Plan. Success 100 %`, while Naive A* had `Planning Time 0.05 s` and `Plan. Success 100 %`. Disturbance recovery improved with VDB grounding from `5.9 s` to `2.6 s` at `r = 1.0 m`, from `9.0 s` to `3.2 s` at `r = 1.5 m`, and from `12.6 s` to `4.4 s` at `r = 2.5 m`. Teacher-student instructional tuning reduced average response length from `45 words` at Episode 1 to `5 words` at Episode 6 while increasing average information relevance from `5 %` to `100 %`. Autonomous node generation succeeded in `80 %`, `80 %`, and `70 %` of trials for the three listed generated nodes, with generation times of `1.5 s`, `5.8 s`, and `5.9 s`. Predictive diagnostics achieved `100 % accuracy` on all single- and multi-thruster failure tests, and decentralised collision avoidance reported `0.05–0.14 s` negotiation times, `0.21–2.32 m` minimum safe distances, and collision-free execution in every run [2507.23735].

AquaBot supplies the most detailed real-world manipulation evidence. For object grasping, `BC (MLP) success: 20/20; average time 13.5 s (σ=3.6 s)`. For trash sorting, the `MLP BC success` rates were `10/10,10/10,9/10` across Toy, Rock, and Plastic categories, versus `8/10,4/10,9/10` for DP. For rescue retrieval with an object of `6.8 kg > robot mass 3.8 kg`, `MLP success: 5/10; DP: 3/10`. The self-learning stage showed that after `120 automated episodes`, the accelerated policy reduced grasp time by `41% relative to human teleoperation` and by `68% relative to BC alone`, and the learned $\delta$ generalized with `19.6%` and `22.9%` speedups on sorting and rescue tasks [2410.18969].

The limitations reported across the literature are specific rather than generic. AquaBot notes that BC can misgeneralize to drastically novel object shapes outside the training distribution, that self-learning depends on reliable success detection, and that the current surrogate optimization scales only speed parameters [2410.18969]. The KG/RAG ablation results show that ungrounded or weakly grounded LLM control is prone to hallucinations and BT incoherence [2507.20370]. The distributed ROS 2 architecture incorporates a Safety Parser and unit-test-gated node generation precisely because runtime autonomy and runtime extensibility introduce failure modes that must be bounded before publication to ROS 2 topics [2507.23735]. A plausible implication is that the central technical challenge for UROSA is not merely autonomy, but autonomy that remains grounded, inspectable, and recoverable under underwater uncertainty.

Source: https://www.emergentmind.com/topics/underwater-robot-self-organizing-autonomy-urosa