Argus

🚀 The Arm Edge Challenge

Deploying high-performance robotics (ROS 2, DDS, AI Agents) across distributed Arm edge hardware (Raspberry Pi 4/5, Apple Silicon, Jetson Orin) involves solving critical system complexities:

• Distributed Fleet Orchestration: Managing remote headless Arm boards from a central development host without brittle manual SSH configurations.

• Hardware-Aware Tiering: Determining whether an edge target can handle full ros-desktop, ros-base, micro-ros, or zenoh-pico based on real-time cache topology, RAM constraints, and thermal limits.

• DDS & Kernel Optimization: Tuning FastDDS/CycloneDDS shared-memory watermarks, socket buffers, and sysctl real-time schedulers specifically for ARMv8/v9 CPU caches.

• AI-Native Control: Enabling autonomous AI agents (Google Antigravity / OpenCode / Claude Code) to directly query edge telemetry, profile SoC registers, and orchestrate ROS 2 topics.

💡 The Solution: Argus Dual-Tier Control Plane

Argus solves this by establishing an autonomous Dual-Tier Control Plane:

1. Mac Mini Host Tier (argus on macOS): Acts as the central command hub. It scans subnets (192.168.1.0/24) and mDNS for ARM targets, establishes self-healing loopback SSH tunnels (localhost:2222), automatically bootstraps remote virtual environments, and exposes a high-level orchestration prompt & Host MCP server.

2. ARM Edge Target Tier (argus natively on Linux/aarch64): Runs directly on edge boards (Raspberry Pi 4/5, etc.). It inspects /proc, /sys, and CPU topology, executes hardware scorecards (assess), runs thermal/RAM stress tests (stress), serves target-side MCP tools, and manages native ROS 2 nodes and topics.

Name Origin: Argus Panoptes — the all-seeing giant of Greek mythology with 100 eyes. Argus sees every detail of your distributed Arm hardware fleet.

Related MCP server: Autoware MCP Server

✨ Key Features

🌐 Host Fleet & Tunneling Tier

• Zero-Config Discovery: argus scan sweeps local network subnets (192.168.1.0/24) and mDNS (.local) for Arm targets.

• Loopback SSH Bridge: argus connect <ID> establishes persistent, auto-reconnecting loopback tunnels (localhost:2222).

• One-Click Bootstrapping: argus bootstrap <ID> deploys Python virtual environments and target daemons over SSH automatically.

• Interactive Host REPL: Context-aware terminal loop (argus [Host]> / argus [Device 1]> ) with instant remote login (argus login 0).

🔍 Deep Arm SoC Profiling

• Multi-OS Detection: macOS (sysctl) and Linux (/proc, /sys, vcgencmd).

• CPU Topology: Pinpoints P/E core layouts, L1/L2/L3 cache line sizes (64B vs 128B), and instruction sets (NEON, SVE, SVE2, LSE).

• Thermal & RAM Sensing: Real-time millisecond thermal zone probes and dynamic memory availability scoring.

📊 ROS 2 Assessment & DDS Tuning

• 5-Tier Scorecard: Evaluates and maps hardware (0–100 score) into ros-desktop, ros-base-full, ros-base, micro-ros, or zenoh-pico.

• 7 Auto-Generated Artifacts:

  • cyclonedds.xml & fastdds.xml: Cache-line aligned fragment sizes and SHM buffer tuning.

  • zenoh_advice.yaml: Recommendations on when to offload DDS to Zenoh.

  • sysctl.conf: Real-time kernel scheduling and network buffer limits.

  • build_flags.json: Arm ISA vectorization flags (-mcpu=cortex-a72 -O3).

  • install_ros2.sh & metadata.yaml.

🤖 AI-Native & Smart TV Robotics

• 31+ MCP Tools Across Tiers: Exposes native host orchestration (argus mcp-host) and target diagnostics (argus mcp) directly to AI agents.

• Smart TV ROS 2 Demo: End-to-end natural language channel/volume controller running inside Raspberry Pi over ROS 2 topics (/smart_tv/command).

🏗️ Dual-Tier Architecture

argus/
├── __main__.py               # Entry point wrapper
├── cli.py                    # OS-Aware CLI dispatcher & interactive REPL loop
├── core/
│   ├── profiler.py           # Deep Arm SoC detection (Cortex-A72, M4, Neoverse)
│   ├── assess.py             # 5-tier ROS 2 scoring algorithm
│   ├── optimizer.py          # 7 DDS/Kernel config artifact generators
│   ├── stresser.py           # Multi-core CPU/RAM/Thermal stress engine
│   ├── ram_sampler.py        # Process & system RAM sampler
│   └── models.py             # Pydantic data structures (Tier, Scorecard, Profile)
├── host/
│   ├── scanner.py            # Subnet & mDNS discovery engine (`argus scan`)
│   ├── bridge.py             # Loopback SSH tunneling, sync, and bootstrap (`connect`, `login`)
│   └── mcp_host.py           # Mac Mini Host MCP Server (`argus mcp-host`)
├── robotics/
│   └── ros_manager.py        # ROS 2 lifecycle, topic pub/echo, and Smart TV deployment
├── ui.py                     # Dynamic cyberpunk UI, Host/Target banners, and `argus dash`
├── mcp/
│   ├── server.py             # Target FastMCP Server (23 tools + resources + prompts)
│   └── resources.py          # 10 hardware/telemetry resource URIs
├── safety/                   # Blast-radius gatekeeper & destructive command blocklist
├── common/logger.py          # Centralized structured telemetry logging (`argus-reports/`)
└── tests/                    # 31 comprehensive pytest unit tests

🖥️ CLI Command Directory

Argus automatically adapts its menu and available commands depending on whether it runs on the Mac Mini Host or natively on the Raspberry Pi Target.

1️⃣ Host Control Tier Commands (Mac Mini / macOS)

2️⃣ Target Edge Tier Commands (Raspberry Pi / Linux / ARM)

🤖 MCP AI Integration

Argus is built from the ground up for Advanced Agentic Coding (Google Antigravity, OpenCode, Claude Code). By configuring MCP servers, AI agents gain full visibility into local host orchestration and remote edge hardware registers.

MCP Configuration Example (~/.opencode/mcp.json or claude_desktop_config.json)

{
  "mcpServers": {
    "argus-host": {
      "command": "argus",
      "args": ["mcp-host", "--transport", "stdio"]
    },
    "argus-pi4": {
      "command": "ssh",
      "args": ["-p", "2222", "armcreate@127.0.0.1", "~/Argus/.venv/bin/argus", "mcp", "--transport", "stdio"]
    }
  }
}

🧰 Target MCP Tools (23 Tools via argus mcp)

• Discovery & Profiling: detect_arm_soc, detect_os, measure_thermal, measure_ram

• Stress & Diagnostics: stress_cpu, stress_memory, assess_hardware

• Config Generation: generate_cyclonedds_config, generate_fastdds_config, generate_zenoh_advice, generate_sysctl_config, generate_build_flags, generate_install_script, generate_all_configs

• Peripherals & UART: detect_serial_ports, configure_micro_ros_uart

• Project & Git Verification: project_list_files, project_read_file, project_write_file, project_git_status, project_git_diff, project_pip_install, project_run_command

🧰 Host MCP Tools (8 Tools via argus mcp-host)

• Fleet Management: host_scan_network, host_list_targets, host_connect_target

• Remote Execution: host_run_on_target, host_assess_target, host_stress_target, host_sync_config

• ROS 2 Proxying: host_deploy_ros2_node, host_check_ros2_topics

📺 ROS 2 & Smart TV Robotics Project

As part of our end-to-end verification, Argus includes a full Natural Language Smart TV Robotics Controller deployed from the Mac Mini Host onto the Raspberry Pi target over ROS 2 topics:

# 1. Deploy & verify the Smart TV node package on the target
argus ros tv-channel --target 0

# 2. Send natural language commands from Mac over ROS 2 bridge
argus ros pub /smart_tv/command std_msgs/msg/String '{"data": "channel up"}' --target 0
argus ros pub /smart_tv/command std_msgs/msg/String '{"data": "mute volume"}' --target 0

# 3. Echo live status updates coming from the Pi
argus ros topics echo /smart_tv/status --target 0

🖥️ Hardware Support Matrix

🧪 Testing & Verification

Argus features a robust suite of 31 unit tests covering hardware detection, determinism, logger persistence, bridge networking, and ROS 2 lifecycle management:

# Activate virtual environment
source .venv/bin/activate

# Execute full pytest suite
pytest -v

Test Summary (31 passed in 0.15s)

• tests/test_core.py: Pi 4 / Pi 5 / Apple SoC fixture parsing, SHA-256 hardware determinism, RAM score formulas (9 tests).

• tests/test_bridge_diagnostics.py: Target resolution, scanning logging, connection checks (3 tests).

• tests/test_host_bridge.py: Loopback bridge forwarding and CLI login simulation (2 tests).

• tests/test_host_scanner.py: Device model serialization and target JSON caching (2 tests).

• tests/test_logger.py: Singleton event logging and structured file retrieval (3 tests).

• tests/test_new_tools.py: Serial port detection, Micro-ROS UART setup, and 23-tool MCP registry verification (6 tests).

• tests/test_ros_manager.py: ROS 2 environment probing, package generation, builds, topic echo/pub, and Smart TV deployment (6 tests).

🏆 Hackathon Highlights (Arm Create 2026)

📜 License

MIT License — see LICENSE for details.