High-performance on-device AI for embedded systems, edge devices, and intelligent machines.

eAI is a C11 embedded AI framework that brings LLM inference, autonomous agents, and adaptive learning directly to resource-constrained devices — from microcontrollers to edge servers. It runs entirely on-device with zero cloud dependency, while supporting optional hybrid connectivity.

eAI is designed for systems where latency matters, connectivity is unreliable, and safety is non-negotiable: robotics, industrial automation, smart cameras, medical devices, autonomous vehicles, and IoT gateways.

• Offline-first: Full autonomy without cloud connectivity
• Resource-aware: Quantized models, power-aware scheduling, memory-conscious design
• Security by default: 8-layer defense architecture from boot to runtime
• Two-tier architecture: Choose the right footprint for your hardware

eAI ships as two distinct product tiers sharing a common foundation:

For MCUs, SBCs, and battery-powered edge devices (Cortex-M7, RPi, nRF5340).

Static footprint: ~50KB RAM | Targets: 80MB–2GB devices

For edge servers, industrial gateways, and high-performance embedded systems (Jetson, x86, i.MX8M).

Includes everything in EAI-Min, plus:

Targets: 512MB–16GB+ devices with multi-protocol connectivity

Embedded systems are resource-limited. eAI addresses this through tailored optimization:

eAI automatically selects the largest model that fits within available RAM and storage:

// Finds best model for device with 512MB RAM, 1GB storage
const eai_model_info_t *model = eai_model_find_best_fit(512, 1024);

The power manager automatically adjusts inference parameters based on battery level and thermal state:

eAI implements a comprehensive, defense-in-depth security posture:

For autonomous AI systems, eAI enforces behavioral boundaries:

• Autonomy Levels: FULL_AUTO → SUPERVISED → MANUAL_ONLY
• Rate Limiting: Configurable max inferences per time window
• Kill Switch: Emergency halt of all autonomous operations
• Category-based rules: HARMFUL, UNSAFE_ACTION, PII_LEAK, INJECTION, OUT_OF_SCOPE

12 curated LLMs optimized for embedded deployment:

Pre-configured profiles for common use cases:

Load a profile:

eai profile robot-controller

• CMake 3.16+
• C11 compiler (GCC 9+, Clang 10+, MSVC 2019+)
• Optional: llama.cpp for real LLM inference

mkdir build && cd build

# Lightweight only
cmake .. -DEAI_BUILD_FRAMEWORK=OFF
make

# Full enterprise platform
cmake .. -DEAI_BUILD_MIN=ON -DEAI_BUILD_FRAMEWORK=ON
make

# With llama.cpp backend
cmake .. -DEAI_LLAMA_CPP=ON -Dllama_DIR=/path/to/llama.cpp/lib/cmake/llama
make

# With tests
cmake .. -DEAI_BUILD_TESTS=ON
make && ctest

#include "eai_min/eai_min.h"

int main(void) {
    // Initialize runtime
    eai_min_runtime_t runtime;
    eai_min_runtime_create(&runtime, EAI_RUNTIME_LLAMA_CPP);
    eai_min_runtime_load(&runtime, "phi-3-mini-q4.gguf", NULL);

    // Initialize power-aware inference
    eai_min_power_t power;
    eai_min_power_init(&power, NULL);
    eai_min_power_set_battery(&power, 75.0f, EAI_POWER_BATTERY);

    // Setup security
    eai_min_security_lite_t sec;
    eai_security_ctx_t ctx;
    eai_security_ctx_init(&ctx, "edge-device-001");
    eai_min_sec_init(&sec, &ctx);
    eai_min_sec_verify_boot(&sec);

    // Run agent
    eai_min_agent_t agent;
    eai_min_agent_init(&agent, &runtime, NULL, NULL);

    eai_agent_task_t task = {
        .goal = "Monitor temperature and report anomalies",
        .max_iterations = 5
    };
    eai_min_agent_run(&agent, &task);

    printf("Result: %s\n", eai_min_agent_output(&agent));

    eai_min_runtime_destroy(&runtime);
    return 0;
}

#include "eai_fw/eai_framework.h"

int main(void) {
    // Runtime manager with multiple backends
    eai_fw_runtime_manager_t rtmgr;
    eai_fw_rtmgr_init(&rtmgr);

    // Security: boot chain + guardrails
    eai_fw_secure_boot_t secboot;
    eai_fw_secboot_init(&secboot);
    eai_fw_secboot_add_chain_entry(&secboot, EAI_BOOT_STAGE_BOOTLOADER,
                                    "bootloader", "sha256:abc123...");
    eai_fw_secboot_verify_chain(&secboot);

    eai_fw_guardrails_t guardrails;
    eai_fw_guard_init(&guardrails);

    // Supply chain verification
    eai_fw_supply_chain_t sbom;
    eai_fw_sc_init(&sbom, "eAI", "0.1.0");
    eai_fw_sc_add_component(&sbom, "llama.cpp", "b3600",
                             "ggerganov", "sha256:...", EAI_LICENSE_MIT);
    eai_fw_sc_verify_all(&sbom);

    // Network security for connectors
    eai_fw_network_security_t netsec;
    eai_fw_netsec_init(&netsec, NULL);

    // Sensor fusion
    eai_fw_sensor_fusion_t fusion;
    eai_fw_fusion_init(&fusion);
    eai_fw_fusion_create_group(&fusion, "temperature", EAI_FUSION_KALMAN);

    // Federated learning
    eai_fw_federated_t fed;
    eai_fw_fed_init(&fed, EAI_FED_COORDINATOR, NULL);
    eai_fw_fed_add_participant(&fed, "device-001");
    eai_fw_fed_add_participant(&fed, "device-002");

    // Cleanup
    eai_fw_rtmgr_shutdown(&rtmgr);
    return 0;
}

eai version                  # Version and build info
eai run                      # Run inference (Min or Framework)
eai serve                    # EIPC server mode
eai status                   # Device info and memory report
eai tools                    # List registered tools
eai profile <name>           # Load deployment profile
eai config <file>            # Load configuration file

eAI/
├── common/                  # Shared foundation
│   ├── include/eai/         # Types, config, log, security, tools, manifest, adaptive
│   └── src/                 # Common implementations
├── min/                     # EAI-Min (Lightweight)
│   ├── include/eai_min/     # Runtime, agent, router, memory, security, sensor, power, ...
│   └── src/                 # Min implementations (10 modules)
├── framework/               # EAI-Framework (Enterprise)
│   ├── include/eai_fw/      # All enterprise modules
│   └── src/                 # Framework implementations (17 modules)
├── platform/                # OS abstraction (Linux, Windows, EoS)
├── models/                  # Model registry (12 curated LLMs)
├── profiles/                # Deployment profiles (5 YAML configs)
├── cli/                     # CLI entry point
├── tests/                   # Unit tests
└── docs/
    ├── compliance/          # ISO 15288, ISO 20243, ISO 25000
    └── qms/                 # Quality management system

eAI is designed and documented following international standards:

• ISO/IEC/IEEE 15288:2023 — System lifecycle processes
• ISO/IEC 20243 (O-TTPS) — Open Trusted Technology Provider Standard
• ISO/IEC 25000 (SQuaRE) — Software quality requirements and evaluation

See docs/compliance/ for traceability matrix, risk register, and audit logs.

MIT License — see LICENSE for details.

Copyright (c) 2026 EoS Project.