⚠️ 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
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)
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/
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
2. Create Virtual Environment
python3 -m venv .venv
source .venv/bin/activate # Linux/macOS
# Windows (WSL recommended)
# .venv\Scripts\activate
3. Install Dependencies
pip install -r requirements.txt
Run the System
python -m src.main
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)
Configuration
All behavior is externalized:
runtime:
timeout: 2
memory:
decay:
weak: 0.9
strong: 0.95
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
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
- Fork the repository
- Create a feature branch
git checkout -b feature/your-feature-name
- Make your changes
- Run tests
pytest -v
- Commit and push
- 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.