Skip to content

Core Concepts

Understanding make87's core components and how they work together is essential for building effective physical AI systems.

Overview

make87 organizes distributed AI systems around four fundamental concepts that work together to create scalable, manageable deployments:

  1. System
  2. Node
  3. Application
  4. Communication
graph TD
    subgraph S["System"]
        subgraph N1["Node 1"]
            A[Application A]
            B[Application B]
        end
        subgraph N2["Node 2"]
            C[Application C]
        end
        subgraph N3["Node 3"]
            D[Application D]
            E[Application E]
        end
    end

    A <-.->|Communication| B
    A <-.->|Communication| C
    B <-.->|Communication| D
    C <-.->|Communication| D
    C <-.->|Communication| E

1. System

A System is the top-level logical container that defines your entire distributed AI deployment. It groups related nodes and applications that work together toward a common goal.

Key Characteristics

  • Logical boundary: All components within a system can communicate with each other
  • Security perimeter: Encrypted overlay network connects all system components
  • Management unit: Deploy, monitor, and scale as a cohesive unit
  • Resource scope: Shared logging, monitoring, and configuration

When to Create Multiple Systems

Create separate systems in the following scenarios:

  • Functional separation: When systems serve different purposes — Example: one system for "Factory Line 1" and another for "Warehouse Security"
  • Security isolation: When different teams need restricted access or have distinct security permissions
  • Geographic separation: When operations are spread across different physical locations, each with its own needs
  • Development stages: To separate environments for development, staging, and production, ensuring safe testing and deployment

Example Systems

  • Smart Factory: Combines quality inspection cameras, robotic assembly arms, and inventory management
  • Autonomous Fleet: Coordinates multiple robots with central planning and monitoring
  • Edge AI Pipeline: Processes sensor data through multiple AI models for real-time decisions

2. Node

A Node is a physical or virtual machine that provides compute resources to run applications. Nodes are the execution environment where your code actually runs.

Types of Nodes

  • Self-Hosted Nodes

    You can deploy make87 on your own infrastructure. This includes:

    • Edge devices, on-premises servers, and cloud-based virtual machines
    • Full access to system configuration and resource management
    • Direct access to local peripherals such as cameras, sensors, and GPUs
    • Self-hosted deployments are supported across all subscription tiers

  • Managed Nodes

    Managed Nodes are cloud instances provisioned and maintained by make87. Key characteristics:

    • Instances are automatically created and managed by make87.
    • Includes automatic updates and infrastructure management.
    • No access to local peripherals such as cameras, sensors, or GPUs.
    • Supported on Team and Enterprise tiers only.

Node Prerequisites

  • Operating System: Any 64-bit Linux distribution
  • Architecture: x86-64 (amd64) or ARM64 (aarch64)
  • Connectivity: Internet connection for management and updates
  • Permissions: sudo access for installation and management

Hardware Examples

  • Edge Devices: NVIDIA Jetson, Raspberry Pi, Intel NUC
  • Industrial PCs: Fanless computers, embedded systems
  • Cloud Instances: AWS EC2, Google Compute, Azure VMs
  • Workstations: Development laptops, desktop computers

3. Application

An Application is containerized software that performs a specific function within your system. Applications are the building blocks that contain your actual business logic, AI models, and device drivers.

Application Characteristics

  • Language-independent: Write in Python, Rust, C++, JavaScript, or any language
  • Containerized: Packaged as Docker containers for consistent deployment
  • Versioned: Semantic versioning with rollback capabilities
  • Configurable: Runtime configuration via environment variables

Application Types

  • Sensor Drivers

    • Interface with cameras, microphones, environmental sensors
    • Publish raw or processed sensor data
    • Handle device-specific protocols and drivers

  • AI/ML Services

    • Run inference on images, audio, sensor data
    • Host trained models (TensorFlow, PyTorch, ONNX)
    • Provide prediction APIs to other applications

  • Business Logic

    • Process AI outputs and make decisions
    • Implement control algorithms and workflows
    • Integrate with external systems and databases

  • User Interfaces

    • Web dashboards for monitoring and control
    • Mobile apps for remote management
    • API gateways for external integration

Application Lifecycle

  1. Development: Write and test code locally or in dev mode
  2. Building: Create versioned container images
  3. Deployment: Deploy to target nodes within a system
  4. Monitoring: Track performance, logs, and health
  5. Updates: Deploy new versions with rollback capability

4. Communication

Communication enables applications to exchange data and coordinate actions across the distributed system. make87 provides secure, protocol-agnostic messaging between any applications in a system.

Communication Patterns

Pattern Use Case Example
Publisher/Subscriber Stream data to multiple consumers Camera → Multiple AI models
Request/Response Query services and get replies Image → Object detection → Results
Server/Client Persistent connections Web dashboard ← System status

Protocol Support

  • Any Protocol: HTTP, WebSockets, Zenoh, MQTT, DDS, ROS2, custom protocols
  • Soft Contracts: Applications declare compatible message types
  • Automatic Discovery: Applications find each other by name, not IP address

Network Architecture

  • Encrypted Overlay: All communication secured with modern cryptography using Noise-based handshake (Curve25519 + ChaCha20-Poly1305) with automatic key rotation for TLS-equivalent security
  • Peer-to-Peer: Direct communication between nodes without central brokers
  • NAT Traversal: Works across firewalls and complex network topologies without manual VPN or firewall configuration
  • Global Reach: Connect edge devices to cloud services seamlessly

How They Work Together

Example: Smart Factory Quality Control

graph LR
    subgraph "Production Line System"
        subgraph "Edge Node 1"
            A[Camera Driver]
            B[Quality Inspector AI]
        end
        subgraph "Edge Node 2"
            C[Robotic Arm Controller]
        end
        subgraph "Cloud Node"
            D[Dashboard Web App]
            E[Database Service]
        end
    end

    A -->|Images| B
    B -->|Pass/Fail| C
    B -->|Results| E
    E -->|Analytics| D

System: "Production Line Quality Control"

  • Nodes: 2 edge devices + 1 cloud instance
  • Applications: Camera driver, AI inspector, robot controller, web dashboard, database
  • Communication: Images flow from camera to AI, decisions flow to robot, results stored in database

Data Flow

  1. Camera Application captures product images and publishes them
  2. AI Application subscribes to images, runs quality inspection, publishes pass/fail decisions
  3. Robot Application subscribes to decisions, controls sorting mechanism
  4. Database Application stores inspection results and analytics
  5. Dashboard Application displays real-time status and historical data

What's Next

Now that you understand make87's core concepts:

For Developers: Learn how to build applications and define their behavior with manifest files

For Infrastructure Teams: Set up nodes and plan your deployment strategy

For Hands-on Learning: Try the quickstart guide to see these concepts in action