GAP: The Ecosystem for Autonomous Intelligence

API Layer and System Integration

The API layer is the GAP platform's primary interface, with over 153 API endpoint files. We use a robust hybrid architecture with Flask (`app.py`) for business logic and FastAPI (`main.py`) for high-performance, asynchronous real-time data streams. The entire system is initialized uniformly via `gap_complete_system.py`, guaranteeing both stability and speed.

Special routes like `patrol_endpoints.py` handle creation, scheduling, and real-time monitoring of autonomous patrol missions, while `xai_endpoints.py` exposes Explainable AI (XAI) features. This provides transparency in AI model decision-making processes, particularly important for regulatory compliance.

Core Systems and Databases

Our core system abstracts data layers, business logic, and interaction with industrial hardware. Robust data modeling with four logically separated databases minimizes the attack surface and maximizes performance:

• `gap.db` (Main Database): Robot data, missions, user profiles, and system configurations.
• `gap_security.db` (Security Database): User authentication (password hashes), JWT tokens, RBAC roles, and audit logs.
• `technical_kb.db` (Knowledge Base): Technical manuals, diagnostic templates, AI models, and calibration data.
• `telemetry.db` (Performance/Monitoring): High-frequency real-time sensor data, system health metrics, and performance logs.

Services Layer

The Services layer contains the complex business logic, decoupled from APIs and data layers. It implements data access patterns (`Repositories`) to handle CRUD operations against the databases, handles middleware for authentication and logging, and standardizes and executes industrial control signals (e.g., Modbus commands) to GAPbots and connected systems. This modular structure ensures flexibility and facilitates scalability.

Core Logic and Monitoring

The core of the GAPbot is `robot_core.py` (over 5400 lines of code), which acts as the robot's central orchestration unit. It handles task states (`TaskStatus`), battery health (`BatteryStatus` - Phase I autonomous charging), and navigation modes (`NavigationMode`). A critical process, `EdgeSystemWatchdog`, monitors all of the robot's local services (AI, servo, MQTT, camera, network) and restarts them automatically in case of failure, ensuring maximum uptime. Control systems like `PID.py` are implemented for precise motor and servo control.

Hardware and Sensor Abstraction

GAPbot has a strict separation between software and physical hardware through a Hardware Abstraction Layer (HAL), enabling easy customization and component swapping. Actuators like `motor_controller.py` and `servo_controller.py` are abstracted to handle movement and tools. The robot is equipped with advanced sensors, including `camera.py` (RGB/IR) for the vision system as well as `ultrasonic_sensor.py` (distance), `infrared_sensor.py` (proximity/detection), and `edge_sensors.py` for direct processing.

MQTT – The Backbone for Edge Communication

Communication between GAP Platform (Broker) and GAPbot (Client) is based on MQTT (Message Queuing Telemetry Transport), an established standard for IoT and M2M. This lightweight protocol enables real-time data transmission and control via `enhanced_mqtt_command_handler.py`:

• Telemetry: GAPbot sends sensor data (GPS, battery, IR, etc.) to GAP via `gapbot/+/telemetry`.
• Status & Alarms: Confirmation of received commands, current task state, and urgent messages (e.g., emergency stop, drive system failure, AI threats) are reported immediately via `gapbot/+/status` and `gapbot/+/alerts`.
• Control Commands: GAP Platform sends specific commands to individual robots via gapbot/{uuid}/commands.
• Configurations: Updates of SLAM maps, speed limits, and other settings are distributed efficiently via gapbot/{uuid}/config.
• Broadcast: Messages that apply to the entire fleet (e.g., global firmware update, fleet-wide emergency stop) are handled via `gapbot/broadcast/*`.

MLOps Pipeline & Data Flow

GAP Platform handles the entire MLOps pipeline, from model training to secure distribution. New, optimized AI models are sent to the GAPbot fleet via Secure OTA (Over-The-Air) updates (Phase I.5), digitally signed with PQC to guarantee integrity. Telemetry data from GAPbots (via `gap_integration_service.py`) is processed, stored in `telemetry.db`, and visualized on the interactive Frontend Dashboard for real-time monitoring and analysis. Also, Offline data caching (Phase I.3) ensures that the robot can continue working and logging data even during network outages.