Skip to content
Intrepid AI Docs

Intrepid AI Architecture

Intrepid AI Platform Architecture Documentation

Welcome to the architecture documentation for Intrepid AI. This document provides an overview of the platform’s structure, the technologies used, and how its components interact to deliver a seamless experience for building, simulating, and deploying robotic applications.

Overview

The Intrepid AI platform enables roboticists to design, test, and deploy robotics operations efficiently. It incorporates a low-code dashboard, an advanced simulator, and a deployment engine. The platform is designed to be extensible, performant, and user-friendly, targeting both novice and expert users.

Core Features

  1. Low-Code Editor: Simplifies robotic behavior design with drag-and-drop nodes and code injection for advanced users.
  2. Simulator: Offers realistic physics and visualizations, borrowing video game technologies like NVIDIA PhysX.
  3. Deployment Engine: Runs deployment graphs natively on bare-metal hardware, avoiding performance overhead from containers or virtual machines.

High-Level Architecture

Here’s a representation of the high-level Intrepid AI architecture:

+-----------------------------+
|        Intrepid Hub         |
|   (Cloud Storage & Assets)  |
+-------------+---------------+
              |
              v
+-----------------------------+
|       Intrepid Dashboard    |
|  (Graph Editor & Projects)  |
+-------------+---------------+
              |
              v
+-----------------------------+       +----------+    +----------+
|      Intrepid Agent CLI     | ----  |   ROS    |    |   Python |
|  (Local Execution Engine)   |       | adapter  |    |    SDK   |
|    Executed on vehicle      |       +----------+    +----------+
+-------------+---------------+
              |
              |
              |
  +-----------+-----------+
  |                       |
  v                       v
+--------+          +------------+
| Nodes  |          | Simulator  |
| (Code) |          | (Physics   |
|        |          | Engine)    |
+--------+          +------------+

The platform comprises the following layers:

1. Frontend

  • Purpose: User interface for designing and managing robotic workflows, collaboration with team members and telemetry visualizations.
  • Technologies:
    • Built using TypeScript with React for a responsive, low-latency experience.
    • Integrated WebSocket support for real-time simulation feedback.
  • Features:
    • Visual programming editor.
    • Node library for behavior customization.
    • Real-time performance monitoring.

2. Backend

  • Purpose: Orchestrates the platform’s operations, processes user inputs, and interfaces with the simulator and deployment systems.
  • Technologies:
    • Developed in Rust for performance and safety.
    • RESTful APIs and WebSocket endpoints.
    • Modular architecture for extensibility.
  • Key Modules:
    • Graph Compiler: Converts user-designed workflows into optimized execution graphs.
    • Simulation Orchestrator: Manages the interaction between the simulator and frontend.
    • ROS2 Integration Module: Bridges the platform with existing robotics middleware.

3. Simulator

  • Purpose: Provides a sandbox environment for validating robotic behaviors before real-world deployment.
  • Technologies:
    • Built using NVIDIA PhysX (or other swappable physics engines) for realistic physics simulations.
    • Scene rendering powered by Rust game development libraries.
  • Features:
    • Multi-robot support.
    • Simulated network stack for communication testing.

4. Deployment Runtime

  • Purpose: Executes robotic workflows on hardware with high efficiency and minimal overhead.
  • Technologies:
    • Written in Rust, running directly on bare-metal systems.
    • Supports API and SDK integrations for custom implementations.
  • Features:
    • Native execution with no reliance on Docker or VMs.
    • Real-time execution monitoring.

System Workflow

1. Design Phase

  • Users design robotic workflows via the low-code dashboard.
  • Custom nodes can be created using embedded scripts or pre-built APIs.
  • The platform compiles the workflow into an optimized execution graph.

2. Simulation Phase

  • The workflow is tested in the simulator, which provides visual feedback and performance metrics.
  • Users can tweak parameters to align with desired behaviors.

3. Deployment Phase

  • Validated workflows are deployed directly to robots.
  • The deployment runtime ensures native performance and robust execution.

Integration Capabilities

  • ROS2 Compatibility: Seamless integration with the ROS2 ecosystem for enhanced interoperability.
  • API & SDK: Power users can integrate their own systems using our extensible API and SDK.
  • Asset Marketplace: Users can extend platform capabilities with pre-built assets.

Future Enhancements

  1. AI-Powered Scenario Generation: Generate complex simulation environments using an integrated Large Language Model (LLM).
  2. Enhanced Analytics: Add dashboards for performance metrics and workflow optimization suggestions.
  3. Cloud Simulation Support: Enable distributed simulations for scaling complex scenarios.

Contributing

Contributions to the Intrepid AI platform are welcome! Please see our contributing.md file for details on how to get involved. Whether you’re interested in building new features, optimizing performance, or reporting issues, we’d love to have your input.

Contact & Support

For technical inquiries, feedback, or support, reach out via:

Let’s build the future of robotics together!