This document describes a revised development and deployment architecture for the Open Autonomous Intelligence Initiative (OAII) that focuses on a single powerful edge platform: the Raspberry Pi 5.

The earlier architecture assumed distributed Pi Zero sensor nodes. This revised blueprint simplifies the environment by consolidating sensing, processing, and event recognition onto a single Pi 5 platform while still remaining aligned with the OAII conceptual model.

The system therefore becomes:

• simpler to deploy
• easier for others to reproduce
• easier to distribute as downloadable software
• well suited for early OAII reference implementations

The goal is to develop an implementation of the OAII abstractions:

Device
Sensor
Signal
Event
Knowledge
Agent
Log

using Python and Raspberry Pi hardware.

1. OAII Architectural Principles

The revised environment follows several core OAII design principles.

Edge‑Primary Intelligence

Signal interpretation and event recognition occur directly on the edge device.

The Pi 5 performs:

• sensor capture
• signal processing
• event inference
• knowledge updates

without requiring external cloud infrastructure.

Simplicity of Deployment

A single Pi 5 can host:

• multiple sensors
• multiple sensor services
• event recognition logic
• system monitoring

This dramatically reduces the complexity of deploying an OAII prototype system.

Separation of Concerns

Software architecture remains layered:

Hardware Adapters

Signal Processing

Event Recognition

Knowledge Models

Agent Logic

Operational Logging

This structure mirrors the OAII abstraction hierarchy.

2. Revised Hardware Roles

The simplified architecture uses two primary device roles.

Development Workstation

A workstation such as a MacBook Air is used for:

• Python development
• Git repository management
• documentation
• remote administration

The workstation functions primarily as a development console.

Edge Intelligence Node

The Raspberry Pi 5 acts as the central OAII device.

This device performs all runtime operations including:

• sensor acquisition
• signal processing
• event recognition
• system monitoring

The Pi 5 therefore acts simultaneously as:

• Device host
• Sensor interface
• Event processor
• Knowledge repository

This configuration dramatically simplifies system architecture.

3. Sensors Supported by a Single Pi 5

A Pi 5 can support multiple sensors simultaneously.

Examples include:

BLE beacon detection

USB microphones

GPIO door sensors

USB cameras

serial sensors

WiFi connected sensors

Because the Pi 5 is significantly more powerful than earlier Pi models, it can comfortably run multiple sensor pipelines simultaneously.

4. Recommended Development Model

The development model emphasizes portability and modularity.

Core OAII Logic Layer

The majority of system logic should be platform‑independent.

Core components include:

• signal processing
• event inference
• knowledge management
• agent behavior
• configuration parsing

These components are implemented as pure Python modules.

Hardware Adapter Layer

Hardware access is isolated in adapter modules.

Examples include:

BLE scanner adapter

microphone adapter

GPIO adapter

camera adapter

network sensor adapter

This layer interacts directly with device drivers and operating system APIs.

Deployment Layer

Operational concerns are handled separately.

These include:

system services

startup scripts

configuration files

installation procedures

5. Standard Repository Structure

Each OAII sensor system should follow a consistent repository structure.

oaii-edge-node/
README.md
pyproject.toml
requirements.txt
requirements-dev.txt
configs/
scripts/
src/
    oaii_node/
        main.py
        config.py
        logging_setup.py
        sensors/
        signals/
        events/
        knowledge/
        agents/
systemd/
tests/

This structure supports separation between:

software logic

configuration

operational deployment

6. Development Toolchain

The recommended toolchain includes:

Python 3

Git

virtual environments

SSH

VS Code or similar editor

Python development practices should include:

• one virtual environment per project
• pinned dependencies
• automated testing
• structured logging

7. Raspberry Pi 5 System Configuration

The Pi 5 should run Raspberry Pi OS.

For most OAII systems the desktop version is convenient during development.

Later deployments may use Raspberry Pi OS Lite.

Initial Setup

During installation configure:

hostname

WiFi credentials

SSH access

timezone

Baseline Software

Install required packages:

python3

pip

python3‑venv

git

Additional packages depend on sensor type.

Examples include:

BlueZ for BLE scanning

ALSA utilities for audio capture

camera libraries

GPIO libraries

8. Sensor Software Deployment

Sensor software should be installed in a predictable location.

Example layout:

/opt/oaii-edge/
app/
venv/
configs/
logs/

Installation typically includes:

Git clone

Python virtual environment

dependency installation

Configuration files remain separate from application code.

9. Service Management

Sensor pipelines should run as systemd services.

Example services include:

oaii-ble-presence.service
oaii-audio-monitor.service
oaii-door-sensor.service

Each service performs a specific sensing or processing function.

10. Testing Strategy

Testing should occur at three levels.

Logic Testing

Core Python logic is tested on the development workstation.

Integration Testing

Linux compatibility is validated on the Pi 5.

Runtime Testing

Sensors and event recognition pipelines are validated directly on the Pi 5.

Operational metrics include:

CPU usage

memory usage

sensor reliability

event latency

11. Simplified OAII Reference Architecture

The revised architecture is intentionally simple.

            Development Console

             MacBook Air

                  │
                  │ SSH / Git
                  │
                  ▼

           Raspberry Pi 5
        OAII Edge Intelligence Node

    BLE Sensors
    Audio Sensors
    GPIO Sensors
    Cameras
    WiFi Sensors

            │
            ▼

      Signal Processing

            │
            ▼

       Event Recognition

            │
            ▼

        Knowledge Models

            │
            ▼

           Agents

The Pi 5 acts as the primary OAII Device hosting all sensing and reasoning functions.

12. OAII Concept‑to‑Implementation Mapping

Conclusion

This revised blueprint establishes a simpler OAII edge intelligence architecture centered on the Raspberry Pi 5.

By consolidating sensing and reasoning onto a single platform, the system becomes easier to build, deploy, and share with others.

This approach is well suited for early OAII reference implementations and demonstrations.