Submission for the All Things Agentic Hackathon — "Ready, Set, Agent!"
HyperOpt-Agent is a production-grade, asynchronous autonomous background worker designed to handle the heavy lifting of high-frequency hardware datasets, automating complex system-level troubleshooting and optimization workflows without human intervention.
Operating directly at the Linux POSIX kernel level of an Intel Core Ultra 7 architecture, the agent completely bypasses cloud dependencies. It executes full-stack cognitive reasoning 100% offline by leveraging Google Genkit paired with Ollama (Llama 3.1), fully accelerated on the local Intel NPU via the Intel IPEX-LLM framework.
Inspired by Stephen Davies' Blueprints and David Tuffley's Beyond Coding, this system moves past brittle rule-based heuristics by fusing distinct software engineering paradigms into a cohesive, secure, and highly adaptable automated administrator (SysAdmin).
The background agent handles massive, non-blocking telemetry streams from the underlying physical infrastructure. Utilizing advanced asynchronous event loops and concurrency primitives (asyncio.gather), the ingestion layer isolates I/O processing. Telemetry polling from Intel Running Average Power Limit (RAPL) registers and POSIX kernel diagnostic channels run simultaneously in isolated threads, preventing scheduling bottlenecks or state starvation.
Instead of reacting to volatile real-time spikes, the agent processes raw telemetry into actionable structures:
- The Riemann Integrator: Applies a discrete definite integral via the trapezoidal rule over the rolling power buffer (W(t)) to compute precise, cumulative energy expenditure in Joules: [\text{Joules} = \int_{t_0}^{t_1} W(t) , dt \approx \sum_{i=1}^{n-1} \frac{W(t_i) + W(t_{i+1})}{2} \Delta t]
- Stochastic Annealing (SA): Feeds the system state space into a localized Simulated Annealing engine. It mathematically searches the core allocation matrix space, avoiding local minima to find the optimal core affinity topology (
taskset).
To parse raw, high-throughput kernel logs (dmesg), the agent utilizes an optimized text scraping compiler inspired by Larry Wall's Perl. Compiling advanced text regular expressions (re.compile), the engine filters structural hardware faults, thermal throttling state indicators, and device drivers errors (such as wireless subsystem anomalies iwlwifi), discarding uninformative system noise with maximum processing throughput.
To guarantee the absolute integrity and authenticity of the chronological dataset against malicious system manipulation or data injection, the pipeline enforces a zero-trust cryptographic signature layer. Every single row appended to the local Tidy Data storage (telemetry_history.csv) is cryptographically signed using an Hash-based Message Authentication Code (HMAC-SHA256) bound to a secured machine key, verified symmetrically before triggering remediation paths.
Before injecting a multi-core affinity mapping directly into the Linux Kernel Scheduler, the proposed allocation vector is subjected to strict, formal runtime constraint verification rules inspired by Jean Ichbiah's Ada. The Ada Guard checks types, index range validation (([0..15]) for Intel Core Ultra 7), and liveness conditions. If the Local LLM experiences an hallucination and outputs an unsafe configuration (e.g., an empty core mask which would trigger a total Operating System deadlock), the system blocks execution, throws a Constraint_Error exception, and falls back to a deterministic safe state.
├── core/
│ ├── __init__.py
│ ├── heuristic.py # Simulated Annealing Engine & Calculus Riemann Integrator Object Space
│ └── kernel.py # Low-level POSIX bindings, dmesg scraper & Intel RAPL driver interfaces
├── data/
│ └── telemetry_history.csv # Flattened Tidy Data database protected by cryptographic signatures
├── kubernetes/ # Cloud Native Orchestration Manifests (Production Ready)
│ ├── storage.yaml # Persistent Volume Claims (ReadWriteMany) for DataFrame shared spaces
│ ├── secret.yaml # Opaque Declarative Secrets
│ ├── sensor-deployment.yaml
│ └── sysadmin-deployment.yaml
├── agent.py # Main Google Genkit Asynchronous Orchestration Core Driver
├── test_hardcore.py # Component Isolation Test Suite (Mathematical & POSIX Verification)
├── test_cycle.py # Full Local NPU Loop Integration Test
├── docker-compose.yml # Multi-Container isolated mesh microservices orchestration
└── requirements.txt # Locked dependencies (genkit, genkit-ollama, pandas, numpy)
The infrastructure runs completely containerized and isolated. For local validation, dependencies can be executed natively in the virtual environment.
Ensure your Ollama local service is configured with Intel IPEX-LLM and running Llama 3.1:
export OLLAMA_MODELS="/path/to/your/models"
./avvia_npu.sh
ollama run llama3.1To verify the multi-paradigm components simultaneously without generating dummy environment flags, execute the concurrent validation pipeline:
sudo ./venv/bin/python3 run_global_tests.pyRun the autonomous background worker directly with Kernel scheduling privileges to begin automated, self-healing system optimization:
sudo ./venv/bin/python3 agent.pyMonitor the heavy lifting of the generated machine dataset processed in the background by checking the Panda Dataframe logs:
tail -f data/telemetry_history.csv- Runs in the Background: Orchestrated as a continuous system daemon that never sleeps, running non-blocking tasks.
- Massive Datasets: Processes high-throughput hardware logs and RAPL telemetry registers at the millisecond scale, consolidating metrics into an HMAC-verified historical series.
- Automates Complex Workflows: Performs automated self-healing by calculating mathematical integrals, validating types, and changing operating system parameters in real-time on the Edge NPU.