agenticros 0.0.1 → 0.1.1

package/runtime/ros2_ws/src/agenticros_bringup/README.md

@@ -0,0 +1,128 @@
+# agenticros_bringup
+
+Launch files and an RViz2 config for **TurtleBot3 in Gazebo** aligned with AgenticROS examples (`/cmd_vel`, `/scan`, rosbridge on port **9090**).
+
+**`package 'agenticros_bringup' not found`:** you must build the workspace and **source the overlay** (not only `/opt/ros/jazzy`):
+
+`cd …/agenticros/ros2_ws && source /opt/ros/jazzy/setup.bash && source install/setup.bash`
+
+## Prerequisites (required for `*_gazebo*` launches)
+
+`agenticros_bringup` does **not** vendor TurtleBot3 or Gazebo. Install them from ROS 2 (Ubuntu, **Jazzy** example):
+
+```bash
+sudo apt update
+sudo apt install ros-jazzy-turtlebot3-gazebo ros-jazzy-rviz2 ros-jazzy-rosbridge-suite
+```
+
+Gazebo is pulled in as a dependency of **`ros-jazzy-turtlebot3-gazebo`**. If `apt` cannot find that package, run `apt search turtlebot3-gazebo` for your distro’s exact name.
+
+Check before launching:
+
+```bash
+source /opt/ros/jazzy/setup.bash
+ros2 pkg prefix turtlebot3_gazebo
+```
+
+If that prints a path under `/opt/ros/jazzy`, launches that use `FindPackageShare('turtlebot3_gazebo')` will work.
+
+**Error: `package 'turtlebot3_gazebo' not found`** — the stack above is not installed (or you only sourced `install/setup.bash` without `/opt/ros/jazzy/setup.bash`). Always source **both**, in order: `source /opt/ros/jazzy/setup.bash` then `source …/ros2_ws/install/setup.bash`.
+
+On **ARM boards** (e.g. Radxa), the binary packages must exist for your Ubuntu + ROS repo; if `apt install` has no candidate, build [turtlebot3_simulations](https://github.com/ROBOTIS-GIT/turtlebot3_simulations) from source into your workspace or use the repo’s **Docker** sim image on an `amd64` host.
+
+## Namespaced `cmd_vel` (AgenticROS `robot.namespace`)
+
+Real robots often use **`/<namespace>/cmd_vel`** (e.g. `/robot3946b404c33e4aa39a8d16deb1c5c593/cmd_vel`). Stock TurtleBot3 Gazebo subscribes to **`/cmd_vel`**. To use the **same** AgenticROS namespace in sim without editing SDF plugins, pass **`robot_namespace`** (the namespace string **without** slashes—same as the plugin’s `robot.namespace` value):
+
+```bash
+ros2 launch agenticros_bringup mode_a_gazebo.launch.py \
+  robot_namespace:=robot3946b404c33e4aa39a8d16deb1c5c593
+```
+
+That starts the package’s built-in **`cmd_vel_relay`** node, republishing `/<namespace>/cmd_vel` → `/cmd_vel` (no `topic_tools` install). It applies to **`gazebo_turtlebot3`**, **`mode_a_*`**, **`turtlebot3_gazebo_rviz`**, and **`rosbridge_gazebo`** launches.
+
+If Gazebo is **already running** in another terminal, start **only** the relay (this does **not** open Gazebo or RViz):
+
+```bash
+ros2 launch agenticros_bringup cmd_vel_bridge.launch.py \
+  src_cmd_vel:=/robot3946b404c33e4aa39a8d16deb1c5c593/cmd_vel
+```
+
+To open **Gazebo** (and optionally **RViz**), use **`mode_a_gazebo.launch.py`**, **`turtlebot3_gazebo_rviz.launch.py`**, or **`rosbridge_gazebo.launch.py`**—not `cmd_vel_bridge.launch.py`.
+
+**RViz:** the bundled config still uses **`/scan`**, **`odom`**, and **`/robot_description`** because TurtleBot3 Gazebo publishes those at the root. If your **physical** robot also namespaces laser or TF, update the RViz displays (LaserScan topic, fixed frame) or add extra relays—only **`cmd_vel`** is bridged by default.
+
+### Teleop / real base moves, but Gazebo (and RViz on the sim) does not
+
+AgenticROS teleop and many stacks publish **`/<namespace>/cmd_vel`** (e.g. `/robot3946…/cmd_vel`). The **real** controller subscribes there, so the hardware moves. Stock **TurtleBot3 Gazebo** subscribes to **`/cmd_vel`** only, so the sim never sees those twists until you **relay** or launch with **`robot_namespace:=...`** so `cmd_vel_relay` is running.
+
+1. Start Gazebo **first** (with or without `robot_namespace`—if without, you must run the bridge below).  
+2. In **another terminal** (same machine, same `ROS_DOMAIN_ID`, both workspaces sourced):
+
+   ```bash
+   ros2 launch agenticros_bringup cmd_vel_bridge.launch.py \
+     src_cmd_vel:=/robot3946b404c33e4aa39a8d16deb1c5c593/cmd_vel
+   ```
+
+   Or one launch that includes sim + relay:
+
+   ```bash
+   ros2 launch agenticros_bringup mode_a_gazebo_rviz.launch.py \
+     robot_namespace:=robot3946b404c33e4aa39a8d16deb1c5c593
+   ```
+
+3. **Check** that something publishes `/cmd_vel` and Gazebo is a subscriber:
+
+   ```bash
+   ros2 topic info /cmd_vel -v
+   ```
+
+   While driving teleop, **`ros2 topic echo /cmd_vel`** should show `Twist` messages; if not, the relay source topic does not match where teleop publishes (run `ros2 topic list | grep cmd_vel`).
+
+**RViz** is only showing the **sim** robot pose from Gazebo’s TF/odom. If the sim never receives `cmd_vel`, the model stays put. (To visualize the **physical** robot instead, point RViz at your real stack’s TF/odom topics—not the TurtleBot3 Gazebo defaults.)
+
+## Launches
+
+| Launch | Purpose |
+|--------|--------|
+| `rosbridge_gazebo.launch.py` | **Rosbridge WebSocket + TurtleBot3 world** — use in Docker or headless hosts. |
+| `gazebo_turtlebot3.launch.py` | Gazebo + TurtleBot3 only (no rosbridge). |
+| `rviz.launch.py` | RViz2 with `turtlebot3_agenticros.rviz` (`odom`, `/scan`, `/robot_description`). |
+| `turtlebot3_gazebo_rviz.launch.py` | Gazebo + RViz on one machine (needs a display). |
+| `mode_a_gazebo.launch.py` | **Mode A:** Gazebo + TurtleBot3 only; sets **`ROS_DOMAIN_ID`** (default `0`). Use with AgenticROS **local** transport—no rosbridge. |
+| `mode_a_gazebo_rviz.launch.py` | **Mode A:** Gazebo + RViz + same domain ID setup. |
+| `cmd_vel_bridge.launch.py` | Relay only: namespaced **`src_cmd_vel`** → **`dst_cmd_vel`** (default `/cmd_vel`). |
+
+### Examples
+
+```bash
+source /opt/ros/jazzy/setup.bash
+source install/setup.bash
+
+# Mode A (local DDS): Gazebo sim on the same machine as OpenClaw + LocalTransport
+ros2 launch agenticros_bringup mode_a_gazebo.launch.py
+# Same + AgenticROS robot.namespace (cmd_vel relay to Gazebo):
+# ros2 launch agenticros_bringup mode_a_gazebo.launch.py robot_namespace:=robot3946b404c33e4aa39a8d16deb1c5c593
+# Optional: ros_domain_id:=1  — must match plugin local.domainId
+
+# Mode A + RViz
+ros2 launch agenticros_bringup mode_a_gazebo_rviz.launch.py
+# …robot_namespace:=... as above if needed
+
+# Simulation + rosbridge (Mode B–style; plugin uses ws://localhost:9090)
+ros2 launch agenticros_bringup rosbridge_gazebo.launch.py
+
+# Gazebo + RViz without forcing ROS_DOMAIN_ID via launch (set export ROS_DOMAIN_ID yourself)
+ros2 launch agenticros_bringup turtlebot3_gazebo_rviz.launch.py
+
+# RViz alone while sim is already running
+ros2 launch agenticros_bringup rviz.launch.py use_sim_time:=true
+```
+
+### Parameters
+
+- **`turtlebot3_model`** — `burger` (default), `waffle`, or `waffle_pi`
+- **`rviz_config`** — path to a different `.rviz` file
+- **`use_sim_time`** — set `true` with Gazebo
+
+See the repository **README** for Docker and OpenClaw plugin settings.

package/runtime/ros2_ws/src/agenticros_bringup/agenticros_bringup/__init__.py

@@ -0,0 +1 @@
+# AgenticROS bringup package

package/runtime/ros2_ws/src/agenticros_bringup/agenticros_bringup/cmd_vel_relay.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Subscribe Twist on input_topic and republish on output_topic (no topic_tools dep)."""
+
+import rclpy
+from geometry_msgs.msg import Twist
+from rclpy.node import Node
+
+
+class CmdVelRelay(Node):
+    def __init__(self) -> None:
+        super().__init__("agenticros_cmd_vel_relay")
+        self.declare_parameter("input_topic", "/cmd_vel_in")
+        self.declare_parameter("output_topic", "/cmd_vel")
+        in_topic = self.get_parameter("input_topic").get_parameter_value().string_value
+        out_topic = self.get_parameter("output_topic").get_parameter_value().string_value
+        self._pub = self.create_publisher(Twist, out_topic, 10)
+        self.create_subscription(Twist, in_topic, self._on_twist, 10)
+        self.get_logger().info("Relay %s -> %s" % (in_topic, out_topic))
+
+    def _on_twist(self, msg: Twist) -> None:
+        self._pub.publish(msg)
+
+
+def main() -> None:
+    rclpy.init()
+    try:
+        rclpy.spin(CmdVelRelay())
+    finally:
+        rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

package/runtime/ros2_ws/src/agenticros_bringup/launch/cmd_vel_bridge.launch.py

@@ -0,0 +1,58 @@
+"""Relay namespaced cmd_vel to the topic TurtleBot3 Gazebo uses (/cmd_vel).
+
+Uses the **agenticros_bringup** `cmd_vel_relay` node (rclpy only—no topic_tools).
+
+This launch does **not** start Gazebo or RViz—only the relay. Start simulation (and optional
+RViz) in **another terminal** first, e.g.::
+
+  ros2 launch agenticros_bringup mode_a_gazebo_rviz.launch.py robot_namespace:=YOUR_NS
+
+Or use a single launch that includes sim + relay::
+
+  ros2 launch agenticros_bringup mode_a_gazebo.launch.py robot_namespace:=YOUR_NS
+
+Example (relay only, sim already running)::
+
+  ros2 launch agenticros_bringup cmd_vel_bridge.launch.py \\
+    src_cmd_vel:=/robot3946b404c33e4aa39a8d16deb1c5c593/cmd_vel
+"""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, LogInfo
+from launch.substitutions import LaunchConfiguration
+from launch_ros.actions import Node
+
+
+def generate_launch_description():
+    return LaunchDescription(
+        [
+            LogInfo(
+                msg=(
+                    "cmd_vel_bridge: starting relay only (no Gazebo/RViz). "
+                    "Use mode_a_gazebo.launch.py, turtlebot3_gazebo_rviz.launch.py, "
+                    "or run this after sim is up in another terminal."
+                )
+            ),
+            DeclareLaunchArgument(
+                "src_cmd_vel",
+                description="Incoming topic (from AgenticROS), e.g. /robot.../cmd_vel",
+            ),
+            DeclareLaunchArgument(
+                "dst_cmd_vel",
+                default_value="/cmd_vel",
+                description="Topic the simulator / base listens on (TurtleBot3 Gazebo: /cmd_vel)",
+            ),
+            Node(
+                package="agenticros_bringup",
+                executable="cmd_vel_relay",
+                name="agenticros_cmd_vel_bridge",
+                output="screen",
+                parameters=[
+                    {
+                        "input_topic": LaunchConfiguration("src_cmd_vel"),
+                        "output_topic": LaunchConfiguration("dst_cmd_vel"),
+                    },
+                ],
+            ),
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/gazebo_turtlebot3.launch.py

@@ -0,0 +1,69 @@
+"""TurtleBot3 in Gazebo (TurtleBot3 world). Matches AgenticROS turtlebot examples: /cmd_vel, /scan.
+
+Optional **robot_namespace**: when set to the same value as AgenticROS **robot.namespace** (no
+leading slash), launches a **topic_tools relay** from `/<namespace>/cmd_vel` to `/cmd_vel` so
+the diff_drive plugin (which listens on `/cmd_vel`) receives commands from the plugin.
+"""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, OpaqueFunction, SetEnvironmentVariable
+from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
+from launch_ros.actions import Node
+from launch_ros.substitutions import FindPackageShare
+
+
+def _launch_setup(context, *args, **kwargs):
+    model = LaunchConfiguration("turtlebot3_model").perform(context)
+    ns = LaunchConfiguration("robot_namespace").perform(context).strip()
+
+    inc = IncludeLaunchDescription(
+        PythonLaunchDescriptionSource(
+            PathJoinSubstitution(
+                [
+                    FindPackageShare("turtlebot3_gazebo"),
+                    "launch",
+                    "turtlebot3_world.launch.py",
+                ]
+            )
+        )
+    )
+    actions: list = [
+        SetEnvironmentVariable(name="TURTLEBOT3_MODEL", value=model),
+        inc,
+    ]
+
+    if ns:
+        ns_clean = ns.strip("/")
+        in_topic = f"/{ns_clean}/cmd_vel"
+        actions.append(
+            Node(
+                package="agenticros_bringup",
+                executable="cmd_vel_relay",
+                name="agenticros_cmd_vel_to_gazebo",
+                output="screen",
+                parameters=[
+                    {"input_topic": in_topic, "output_topic": "/cmd_vel"},
+                ],
+            )
+        )
+
+    return actions
+
+
+def generate_launch_description():
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "turtlebot3_model",
+                default_value="burger",
+                description="TurtleBot3 model: burger | waffle | waffle_pi",
+            ),
+            DeclareLaunchArgument(
+                "robot_namespace",
+                default_value="",
+                description="Same as AgenticROS robot.namespace (no slashes). When non-empty, relays /<namespace>/cmd_vel -> /cmd_vel for Gazebo (built-in cmd_vel_relay node).",
+            ),
+            OpaqueFunction(function=_launch_setup),
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/mode_a_gazebo.launch.py

@@ -0,0 +1,55 @@
+"""
+Gazebo + TurtleBot3 for **Mode A (local DDS)**.
+
+Runs the standard TurtleBot3 world so topics (`/cmd_vel`, `/scan`, etc.) are on the
+local ROS 2 domain. Use with AgenticROS **transport: local** and the same
+**ROS_DOMAIN_ID** as set here (default `0`). No rosbridge required if OpenClaw runs
+on this machine with LocalTransport.
+"""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, SetEnvironmentVariable
+from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description():
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "ros_domain_id",
+                default_value="0",
+                description="ROS_DOMAIN_ID; must match AgenticROS local transport domainId",
+            ),
+            SetEnvironmentVariable(
+                name="ROS_DOMAIN_ID",
+                value=LaunchConfiguration("ros_domain_id"),
+            ),
+            DeclareLaunchArgument(
+                "robot_namespace",
+                default_value="",
+                description="Same as AgenticROS robot.namespace; relays /<ns>/cmd_vel -> /cmd_vel",
+            ),
+            DeclareLaunchArgument(
+                "turtlebot3_model",
+                default_value="burger",
+                description="TurtleBot3 model: burger | waffle | waffle_pi",
+            ),
+            IncludeLaunchDescription(
+                PythonLaunchDescriptionSource(
+                    PathJoinSubstitution(
+                        [
+                            FindPackageShare("agenticros_bringup"),
+                            "launch",
+                            "gazebo_turtlebot3.launch.py",
+                        ]
+                    )
+                ),
+                launch_arguments={
+                    "robot_namespace": LaunchConfiguration("robot_namespace"),
+                    "turtlebot3_model": LaunchConfiguration("turtlebot3_model"),
+                }.items(),
+            ),
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/mode_a_gazebo_rviz.launch.py

@@ -0,0 +1,48 @@
+"""
+Gazebo + TurtleBot3 + RViz for **Mode A (local DDS)**.
+
+Sets **ROS_DOMAIN_ID** for the whole tree, then starts simulation + RViz with
+**use_sim_time:=true**. Configure AgenticROS with **transport: local** and the same domain.
+"""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, SetEnvironmentVariable
+from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description():
+    bringup = FindPackageShare("agenticros_bringup")
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "ros_domain_id",
+                default_value="0",
+                description="ROS_DOMAIN_ID; must match AgenticROS local domainId",
+            ),
+            SetEnvironmentVariable(
+                name="ROS_DOMAIN_ID",
+                value=LaunchConfiguration("ros_domain_id"),
+            ),
+            DeclareLaunchArgument(
+                "robot_namespace",
+                default_value="",
+                description="Same as AgenticROS robot.namespace; enables cmd_vel relay",
+            ),
+            DeclareLaunchArgument(
+                "turtlebot3_model",
+                default_value="burger",
+                description="TurtleBot3 model: burger | waffle | waffle_pi",
+            ),
+            IncludeLaunchDescription(
+                PythonLaunchDescriptionSource(
+                    PathJoinSubstitution([bringup, "launch", "turtlebot3_gazebo_rviz.launch.py"])
+                ),
+                launch_arguments={
+                    "robot_namespace": LaunchConfiguration("robot_namespace"),
+                    "turtlebot3_model": LaunchConfiguration("turtlebot3_model"),
+                }.items(),
+            ),
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/realsense_rosbridge.launch.py

@@ -0,0 +1,154 @@
+"""RealSense + rosbridge + cmd_vel relay — host-side stack for the NemoClaw hybrid setup.
+
+This launch is intended to run **on the host** (or robot) alongside a NemoClaw
+sandbox that hosts the AgenticROS OpenClaw plugin. The plugin connects to
+rosbridge on this host via ``ws://host.docker.internal:9090`` (i.e.
+``ws://172.19.0.1:9090`` from inside the sandbox).
+
+Topics published by realsense2_camera (default ``camera_name=camera``)::
+
+    /camera/camera/color/image_raw                       sensor_msgs/Image
+    /camera/camera/color/image_raw/compressed            sensor_msgs/CompressedImage (via image_transport_plugins)
+    /camera/camera/depth/image_rect_raw                  sensor_msgs/Image
+    /camera/camera/aligned_depth_to_color/image_raw      sensor_msgs/Image
+
+cmd_vel relay: the AgenticROS plugin publishes Twist on
+``/<robot_namespace>/cmd_vel``. This launch relays that to ``/cmd_vel`` so a
+robot base controller listening on the unnamespaced topic still gets driven.
+Disable the relay by setting ``relay_cmd_vel:=false``.
+
+Example::
+
+    ros2 launch agenticros_bringup realsense_rosbridge.launch.py \\
+        robot_namespace:=3946b404-c33e-4aa3-9a8d-16deb1c5c593 \\
+        enable_depth:=true \\
+        align_depth:=true
+"""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, GroupAction, IncludeLaunchDescription, LogInfo
+from launch.conditions import IfCondition
+from launch.launch_description_sources import AnyLaunchDescriptionSource, PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution, PythonExpression
+from launch_ros.actions import Node
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description() -> LaunchDescription:
+    realsense = IncludeLaunchDescription(
+        PythonLaunchDescriptionSource(
+            PathJoinSubstitution(
+                [FindPackageShare("realsense2_camera"), "launch", "rs_launch.py"]
+            )
+        ),
+        launch_arguments={
+            "camera_name": "camera",
+            "camera_namespace": "camera",
+            "enable_color": LaunchConfiguration("enable_color"),
+            "enable_depth": LaunchConfiguration("enable_depth"),
+            "align_depth.enable": LaunchConfiguration("align_depth"),
+            "rgb_camera.color_profile": LaunchConfiguration("color_profile"),
+            "depth_module.depth_profile": LaunchConfiguration("depth_profile"),
+            "pointcloud.enable": "false",
+        }.items(),
+    )
+
+    rosbridge = IncludeLaunchDescription(
+        AnyLaunchDescriptionSource(
+            PathJoinSubstitution(
+                [FindPackageShare("rosbridge_server"), "launch", "rosbridge_websocket_launch.xml"]
+            )
+        ),
+        launch_arguments={
+            "port": LaunchConfiguration("rosbridge_port"),
+            "address": LaunchConfiguration("rosbridge_address"),
+        }.items(),
+    )
+
+    cmd_vel_relay = GroupAction(
+        actions=[
+            Node(
+                package="agenticros_bringup",
+                executable="cmd_vel_relay",
+                name="agenticros_cmd_vel_bridge",
+                output="screen",
+                parameters=[
+                    {
+                        "input_topic": PythonExpression(
+                            [
+                                "'/' + '",
+                                LaunchConfiguration("robot_namespace"),
+                                "'.strip('/') + '/cmd_vel'",
+                            ]
+                        ),
+                        "output_topic": LaunchConfiguration("dst_cmd_vel"),
+                    }
+                ],
+            ),
+        ],
+        condition=IfCondition(LaunchConfiguration("relay_cmd_vel")),
+    )
+
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "robot_namespace",
+                default_value="3946b404-c33e-4aa3-9a8d-16deb1c5c593",
+                description="ROS2 namespace AgenticROS publishes cmd_vel under, e.g. 3946b404-...",
+            ),
+            DeclareLaunchArgument(
+                "dst_cmd_vel",
+                default_value="/cmd_vel",
+                description="Topic the robot base listens on; the relay republishes namespaced cmd_vel here.",
+            ),
+            DeclareLaunchArgument(
+                "relay_cmd_vel",
+                default_value="true",
+                description="Relay /<robot_namespace>/cmd_vel -> dst_cmd_vel.",
+            ),
+            DeclareLaunchArgument(
+                "rosbridge_port",
+                default_value="9090",
+                description="rosbridge_websocket port (sandbox connects via host.docker.internal:9090).",
+            ),
+            DeclareLaunchArgument(
+                "rosbridge_address",
+                default_value="0.0.0.0",
+                description="rosbridge_websocket bind address; 0.0.0.0 lets the docker bridge reach it.",
+            ),
+            DeclareLaunchArgument(
+                "enable_color",
+                default_value="true",
+                description="Enable RealSense RGB color stream.",
+            ),
+            DeclareLaunchArgument(
+                "enable_depth",
+                default_value="true",
+                description="Enable RealSense depth stream.",
+            ),
+            DeclareLaunchArgument(
+                "align_depth",
+                default_value="true",
+                description="Publish depth aligned to color (better for ros2_depth_distance center sampling).",
+            ),
+            DeclareLaunchArgument(
+                "color_profile",
+                default_value="640x480x15",
+                description="RealSense color profile WxHxFPS; lower fps reduces rosbridge bandwidth.",
+            ),
+            DeclareLaunchArgument(
+                "depth_profile",
+                default_value="640x480x15",
+                description="RealSense depth profile WxHxFPS.",
+            ),
+            LogInfo(
+                msg=(
+                    "agenticros_bringup: launching RealSense + rosbridge (0.0.0.0:9090) + cmd_vel relay."
+                    " The NemoClaw sandbox should connect to ws://host.docker.internal:9090."
+                )
+            ),
+            realsense,
+            rosbridge,
+            cmd_vel_relay,
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/rosbridge_gazebo.launch.py

@@ -0,0 +1,54 @@
+"""Rosbridge WebSocket + TurtleBot3 Gazebo world — same topology the AgenticROS Docker image expects (ws://…:9090)."""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription
+from launch.launch_description_sources import AnyLaunchDescriptionSource, PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description():
+    rosbridge = IncludeLaunchDescription(
+        AnyLaunchDescriptionSource(
+            PathJoinSubstitution(
+                [
+                    FindPackageShare("rosbridge_server"),
+                    "launch",
+                    "rosbridge_websocket_launch.xml",
+                ]
+            )
+        ),
+    )
+
+    gazebo = IncludeLaunchDescription(
+        PythonLaunchDescriptionSource(
+            PathJoinSubstitution(
+                [
+                    FindPackageShare("agenticros_bringup"),
+                    "launch",
+                    "gazebo_turtlebot3.launch.py",
+                ]
+            )
+        ),
+        launch_arguments={
+            "turtlebot3_model": LaunchConfiguration("turtlebot3_model"),
+            "robot_namespace": LaunchConfiguration("robot_namespace"),
+        }.items(),
+    )
+
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "turtlebot3_model",
+                default_value="burger",
+                description="TurtleBot3 model: burger | waffle | waffle_pi",
+            ),
+            DeclareLaunchArgument(
+                "robot_namespace",
+                default_value="",
+                description="Same as AgenticROS robot.namespace; enables cmd_vel relay to /cmd_vel",
+            ),
+            rosbridge,
+            gazebo,
+        ]
+    )

package/runtime/ros2_ws/src/agenticros_bringup/launch/rviz.launch.py

@@ -0,0 +1,38 @@
+"""RViz2 with a TurtleBot3-friendly layout: grid, TF, robot model, laser scan (/scan)."""
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument
+from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
+from launch_ros.actions import Node
+from launch_ros.parameter_descriptions import ParameterValue
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description():
+    pkg = FindPackageShare("agenticros_bringup")
+    default_cfg = PathJoinSubstitution([pkg, "rviz", "turtlebot3_agenticros.rviz"])
+
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument(
+                "rviz_config",
+                default_value=default_cfg,
+                description="Path to an RViz2 config file",
+            ),
+            DeclareLaunchArgument(
+                "use_sim_time",
+                default_value="false",
+                description="Set true when Gazebo (or other sim) is publishing /clock",
+            ),
+            Node(
+                package="rviz2",
+                executable="rviz2",
+                name="rviz2",
+                arguments=["-d", LaunchConfiguration("rviz_config")],
+                parameters=[
+                    {"use_sim_time": ParameterValue(LaunchConfiguration("use_sim_time"), value_type=bool)}
+                ],
+                output="screen",
+            ),
+        ]
+    )