aether-robotics 3.5.0

Autonomous multi-agent robotics system with DRL-First Hybrid FDIR

    ████████████████████████████████
   ████████████████████████████████
  █████╔═══════════════════╗█████
  █████║  ▄████▄   ▄████▄  ║█████
  █████║ ████████████████ ║█████
  █████║ ██████████████ ║█████
  █████║ █▀▀████████▀▀█ ║█████
  █████║  ▀████▀   ▀████▀  ║█████
  █████║▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄║█████
  █████║  ━━━━━━━━━━━━━━━  ║█████
  █████║  ▌ AETHER  v3 ▐  ║█████
  █████║  ━━━━━━━━━━━━━━━  ║█████
  █████╚═══════════════════╝█████
   ████████████████████████████████
    ████████████████████████████████

AETHER — Autonomous Robotics Operating System

AETHER is the autonomous operating system for robots. Plug in and talk to your robot in plain English and ask it to do anything you want.

AETHER connects to whatever hardware is present at startup, discovers every actuator through an interactive GPIO calibration walk, and writes a physical_map of every servo and motor by BCM pin. That map feeds into an LLM planner that translates plain-English objectives into the correct hardware action — pin pre-filled, servo type resolved, direction inferred. Motion commands dispatch to GPIO, while a PPO fault-detection network runs concurrently on the 15-dimensional sensor observation vector, detecting and recovering from failures in real time. Every layer — discovery, pin mapping, natural-language planning, execution, fault recovery — runs on a Raspberry Pi with no cloud dependency except the Anthropic API for the planner.

Demo and docs → aether-robotics.com

---

Quick Start

pip install aether-robotics
aether --calibrate
aether --mode agent

Calibration walks every safe GPIO pin (BCM 4–27, excluding I2C/SPI/UART), pulses each with a positional servo sweep, and prompts you to label what moved. The result is a physical_map saved in your calibration profile and loaded automatically at next startup.

Once calibrated:

objective> move the wheel forward for 5 seconds
[PLAN]  [LLM]  servo_cont_wheel
[EXEC]  servo_cont_wheel(speed=50, duration=5)
[OK]    success=True  (5009ms)

AETHER discovered the wheel on BCM 17 during calibration, the planner mapped "wheel forward" to the calibrated action, the servo spun for 5 seconds and stopped.

---

What AETHER Does That Others Don't

• Discovers the robot. Calibration walks every GPIO pin, you label what moved, AETHER builds a physical_map with BCM pin, device type, and action label for each actuator (unlike ROS/Viam where you configure drivers manually before the system knows what hardware exists).
• Publishes the Robot Genome. Every calibrated robot gets a versioned robot.json identity card — a stable, portable description of its locomotion class, actuators, and sensors. Capabilities are derived deterministically from the genome (same hardware = same capability set), so skills written for a differential_drive genome run on every matching robot without wiring changes. See docs/robot-genome-v1.md for the published schema.
• Speaks natural language. Type plain English; the LLM planner resolves intent against your robot's genome capabilities and dispatches the correct actuator — BCM pin pre-filled, servo type resolved, direction inferred (unlike ROS action servers that require typed message structs and correct namespace knowledge).
• Detects faults in real time. DRL-First Hybrid FDIR achieves SFRI 69.99, 100% detection rate, and 100% recovery rate over 6,023 real-hardware steps (unlike threshold-rule systems that require manual parameter tuning per platform and miss novel fault signatures).
• Improves through use. Correction traces are logged per step; operational memory and sim-to-real action transfer are on the roadmap (unlike static planners that repeat the same failure mode without feedback).

Robot Genome

aether --genome show

Robot Genome
  ID:         f47ac10b-...
  Locomotion: differential_drive
  Hash:       a3f1d92e...

Capabilities (6)
  drive_backward  drive_forward  emergency_stop  stop  turn_left  turn_right

The genome is stored at configs/robot.json and auto-migrates from physical_map on first load of a v3.4.x profile. Skills declare SKILL_REQUIRES = ["drive_forward", ...] and AETHER rejects skills the robot's genome cannot satisfy — before any hardware moves. Full schema, derivation rules, and skill authoring guide: docs/robot-genome-v1.md.

---

Commands

Modes

Flag	Description
--mode sim	Simulation with fault injection against a virtual robot (default)
--mode agent	Interactive LLM-planned objectives on live hardware; prompts for input
--mode realworld	Continuous live-hardware FDIR loop — camera + system sensors, no planner
--mode server	HTTP API on --port; accepts POST /objective and GET /health
--mode dashboard	Flask web UI on port 5000 with live objective submission and OLED preview

Useful Flags

Flag	When to use
--calibrate	First-time setup — walks every GPIO pin, you label what moves
--recalibrate	Re-run the full pin walk (e.g. after wiring changes); skips known-empty pins; preserves robot_id
--auto-calibrate	Headless calibration with no interactive prompts
--genome show	Print the loaded robot genome (locomotion, actuators, capabilities) and exit
--once "objective"	Run a single objective non-interactively and exit; useful in scripts
--task "objective"	Task description for --mode sim
--schedule "..."	Scheduled runs: "every 30s: scan environment", "for 5min: obj", "until 22:00: obj"
--continuous	Run --mode realworld indefinitely until Ctrl-C
--servo-pin N	Override the servo GPIO BCM pin for this session (supersedes calibration profile)
--robot {rover_v1,drone_v1}	Robot config for --mode sim (default: rover_v1)
--faults {disabled,enabled,heavy}	Fault injection level for sim/realworld (default: disabled)
--scenario TEXT	Sim scenario: simple, obstacles, imu_fault, battery, compound, fault_heavy
--max-steps N	Max steps per episode (default: 300)
--seed N	Random seed for reproducible sim runs (default: 42)
--render	Print ASCII state render at each sim step
--plots	Generate matplotlib SFRI/metrics plots after a sim run
--no-learning	Freeze PPO weights — useful for controlled benchmarking
--port N	Port for --mode server (default: 8080)
--auto-install	Install missing Python packages without prompting
--auto-update	Pull the latest version without prompting
--no-install	Skip the package-install prompt entirely
--no-update	Skip the update check
--verbose	Enable debug logging

---

Supported Hardware

Tested and working

Raspberry Pi 4 Model B · USB camera or picamera2 · GPIO servos (positional or continuous-rotation) · SSD1306 OLED over SPI · Anthropic API (LLM planner and vision)

Should work, unverified

Pi Zero 2 W · Pi 5 (requires rpi-lgpio in place of RPi.GPIO) · PCA9685 I2C 16-channel servo driver · MAVLink flight controllers via USB serial

In development

Arduino/ESP32 serial bridge · ArduPilot drone support · multi-robot coordination

---

Architecture

  User input (plain English)
        │
        ▼
  ToolDiscovery ──────────────► physical_map  (saved calibration profile)
        │                                  │
        ▼                                  ▼
  LLMPlanner ◄──── physical_map injected into planner context
        │
        ▼
  NavigationEngine  (L1 camera / L2 GPIO / L3 MAVLink)
        │                         │
        ▼                         ▼
  Hardware (servo/motor/FC)  FaultAgent (PPO, 15-dim obs → fault class)
                                   │
                             detect · recover · log

---

Benchmarks

Real-hardware deployment: Raspberry Pi 4, GPIO servos, live camera, Anthropic API planner.

Metric	Value	Conditions
SFRI	69.99	6,023 steps, real hardware
MTTR	1.35 steps	Mean time to recover from injected fault
Detection rate	100%	0 misses, 0 false positives

SFRI (Stability Fault Recovery Index) = 35×DR + 25×(1 − MTTR/max_steps) + 10×RR − 30×FPR. Range 0–70; higher is better.

---

Roadmap

• ✓ Phase 1 — Reverse Engineering — GPIO pin walk, physical_map, LLM-planned hardware control
• �� Phase 2 — Robot Genome — versioned robot.json schema, deterministic capability derivation, skill portability (docs/robot-genome-v1.md)
• Phase 3 — Vision-Language Grounding — "follow the orange cone", scene-grounded navigation, in progress
• Phase 4 — Operational Memory + Sim-to-Real Action Transfer
• Phase 5 — Multi-robot coordination

---

Early Access

AETHER is in early access. We're working with a small number of robotics teams and researchers to refine the platform. Email [e-mail] for access.

---

Citation

@software{aether2026,
  title   = {AETHER: Autonomous Operating System for Robots},
  author  = {Paatur, Chahel},
  year    = {2026},
  version = {3.4.3},
  url     = {https://aether-robotics.com},
  note    = {DRL-First Hybrid FDIR with physical-map calibration and LLM planning},
}

---

AETHER is proprietary software in early access. All rights reserved. © 2026 Chahel Paatur.