DEV Community

Swapin Vidya
Swapin Vidya

Posted on

PeachBot Edge: A Deterministic Edge Execution Engine for Stateful Signal Processing

#peachbot #ai #machinelearning #edge

⚠️ Scope & Status

This repository represents an early-stage execution engine prototype within the PeachBot system.

  • Focused on experimentation and system design
  • Not production-ready
  • Not a medical or diagnostic system

The goal is to explore how stateful, deterministic systems can operate reliably on edge devices.

What PeachBot Edge Is

PeachBot Edge is the execution layer of the PeachBot ecosystem.

It is designed to:

  • Process signals locally (edge-first)
  • Maintain system state over time
  • Execute structured workflows deterministically

This repo focuses on runtime behavior, not model training or cloud pipelines.

Why This Exists

Most systems rely on:

input → model → output
Enter fullscreen mode Exit fullscreen mode

This works well in controlled environments, but can be limiting when:

  • Connectivity is unstable
  • Latency matters
  • Context must persist over time

This project explores:

How to build a system that processes signals continuously and maintains context locally.

Core Execution Flow

From the current implementation:

Input Signal
    ↓
Signal Classification
    ↓
Context Construction
    ↓
Execution (core modules)
    ↓
State Update (memory + priority)
    ↓
Optional coordination (metadata)
Enter fullscreen mode Exit fullscreen mode

This enables:

  • Stateful processing
  • Context-aware execution
  • Predictable system behavior

Key Components

Runtime Engine

  • Executes workflows as a graph
  • Supports conditional routing

Memory Layer

  • Maintains system state
  • Applies decay and priority

Signal Layer

  • Classifies signals (normal / anomaly / critical)
  • Builds execution context

Safety Layer

  • Handles failures
  • Provides fallback mechanisms

Hardware Layer

  • Adapts execution based on device constraints

Coordination Adapter

  • Supports metadata exchange across nodes
  • No raw data transfer

Project Structure 

src/
  runtime/        # execution engine
  communication/  # coordination layer
  monitoring/     # logging
  contracts/      # structured inputs

configs/
  config.yaml     # system behavior

tests/
docs/
Enter fullscreen mode Exit fullscreen mode

What Currently Works

  • Deterministic execution pipeline
  • Stateful memory updates
  • Graph-based workflow execution
  • Config-driven behavior
  • Testable system components

Current Limitations

  • Limited real-world deployment
  • No large-scale benchmarking
  • Some modules still evolving
  • Hardware-level optimization is ongoing

Installation

1. Clone Repository 

git clone https://github.com/peachbotAI/peachbot-edge.git
cd peachbot-edge
Enter fullscreen mode Exit fullscreen mode

2. Create Virtual Environment 

python3 -m venv .venv
source .venv/bin/activate   # Linux/macOS

# Windows (WSL recommended)
# .venv\Scripts\activate
Enter fullscreen mode Exit fullscreen mode

3. Install Dependencies 

pip install -r requirements.txt
Enter fullscreen mode Exit fullscreen mode

Run the System 

python -m src.main
Enter fullscreen mode Exit fullscreen mode

You should see:

  • System boot logs
  • Configuration load
  • Execution traces

Quick Example (Signal Dispatch) 

from src.runtime.graph.executor import GraphExecutor
from src.contracts.payload import SignalPayload

executor = GraphExecutor()

signal = SignalPayload(
    source="sensor_01",
    data={"value": 42},
    priority=1.0
)

result = executor.dispatch(signal)
print(result.state)
Enter fullscreen mode Exit fullscreen mode

Configuration

All behavior is externalized:

runtime:
  timeout: 2

memory:
  decay:
    weak: 0.9
    strong: 0.95
Enter fullscreen mode Exit fullscreen mode

This allows tuning without modifying core logic.

💻 Hardware Compatibility

The system is designed to be hardware-agnostic at the software level.

✔ Tested

  • Windows (development machine)
  • CPU-only execution

🔄 Target (Compatible)

  • Linux edge devices
  • Raspberry Pi (SBC)
  • Custom embedded hardware

⚙️ Why It Works

  • Pure Python runtime
  • No GPU dependency
  • Config-driven execution
  • No cloud requirement

⚠️ Notes

  • Performance varies by hardware
  • SBC deployment may require tuning
  • Optimization is ongoing

Design Approach

This project focuses on:

  • Edge-first execution
  • Deterministic processing
  • Config-driven behavior
  • Modular architecture

Where This Can Be Used (Exploratory)

  • Environmental monitoring
  • Edge analytics pipelines
  • Real-time alerting systems

(Exploratory directions, not production claims.)

Integration Context

This repo works alongside:

  • Core → system logic
  • Deploy → execution control
  • FILA → coordination

This layer focuses specifically on runtime execution.

Testing 

pytest -v
Enter fullscreen mode Exit fullscreen mode

Final Note

This is an execution engine prototype, not a finished AI platform.

The aim is to explore:

How systems can operate reliably, predictably, and locally under real-world constraints.

Contributing

This repository is part of an evolving system, and contributions are welcome—especially from developers interested in edge systems, deterministic execution, and distributed architectures.

Where You Can Contribute

** Runtime & Execution**

  • Graph execution improvements
  • Performance optimization (CPU/memory)
  • Deterministic scheduling

** State & Memory Layer**

  • Memory decay strategies
  • Priority tuning models
  • State validation mechanisms

** Signal & Context Processing**

  • Signal classification improvements
  • Context enrichment strategies
  • Domain-specific signal adapters

** Safety & Reliability**

  • Fault handling mechanisms
  • Timeout strategies
  • Deterministic fallback logic

** Edge & Hardware**

  • Raspberry Pi / SBC testing
  • Resource-constrained optimization
  • Hardware-aware execution tuning

How to Contribute

  1. Fork the repository
  2. Create a feature branch 
   git checkout -b feature/your-feature-name
Enter fullscreen mode Exit fullscreen mode
  1. Make your changes
  2. Run tests 
   pytest -v
Enter fullscreen mode Exit fullscreen mode
  1. Commit and push
  2. Open a Pull Request

Contribution Guidelines

  • Keep implementations deterministic (no randomness)
  • Avoid hardcoded logic → use config-driven design
  • Maintain edge-first constraints (low memory, no cloud dependency)
  • Ensure all tests pass before submitting

Repository

👉 https://github.com/peachbotAI/peachbot-edge

Note

This is an early-stage system, so clarity, simplicity, and testability are prioritized over complexity.

If you're unsure where to start, feel free to open an issue or discussion.

Disclaimer

This system does not provide medical decisions or diagnostics.

Outputs should be interpreted as system-level signals or computational results only.

Top comments (0)