AION-CORE
Neuro-Symbolic Inference Framework
v1.0.0-Beta
AION-CORE is a neuro-symbolic inference framework that fuses deep learning anomaly detection with formal symbolic reasoning — and does it on hardware that fits in a laptop.
It takes raw telemetry streams, runs them through a quantized neural perceptor, translates the results into formal logical predicates, reasons over those predicates using a recursive tree-walk evaluator, and produces human-auditable proof trees explaining every conclusion. Every step runs at verified sub-millisecond latency.
This is not a prototype. It is an engineering statement: real-time AI inference does not require a GPU cluster.
Most AI frameworks assume unlimited compute. AION-CORE assumes the opposite.
The entire pipeline — from raw packet ingestion to symbolic proof generation — is engineered for a single AMD Ryzen™ 5 PRO 4650U (Zen 2, 6 cores, 16GB RAM). While NVIDIA GPUs remain the standard for training large models, AION-CORE's inference layer is hand-tuned for high-performance CPU execution. This is not a compromise — it is a deliberate architectural choice:
| Decision | Rationale |
|---|---|
| INT8 dynamic quantization | 2-3× inference speedup over FP32 with no measurable accuracy loss. Zen 2's integer pipelines are underutilized by FP-heavy frameworks — we exploit them. |
| Thread pinning to 6 physical cores | Eliminates the ~15-20% SMT contention penalty on Zen 2's shared FP/SIMD units. Benchmarked, not assumed. |
| Bounded-channel backpressure (8192 records) | Prevents memory exhaustion under telemetry bursts without dropping data. Cooperative flow control between Rust and Python — no shared locks. |
| WAL-bounded persistence (512MB checkpoint) | Caps DuckDB write amplification, keeping the 16GB system responsive during sustained ingestion. |
The result: a framework deployable on edge servers, industrial controllers, or any x86-64 Linux box — without a GPU in sight.
All benchmarks from a 20,000-packet stress test on the target hardware:
| Stage | P50 Latency | P99 Latency |
|---|---|---|
| Telemetry Ingestion | 0.89 μs | 3.56 μs |
| Neural Inference (INT8, batch=64) | 0.685 ms | 1.221 ms |
| Symbolic Translation | 0.116 ms | 0.190 ms |
| End-to-End Pipeline | < 1 ms | < 4 ms |
Telemetry Source
│
▼
┌─────────────────┐ UDS + Nonce Auth
│ Nexus-Bridge │◄──────────────────────┐
│ (Rust / Tokio) │ │
│ Backpressure │ ┌─────────────────┴──────────┐
│ DuckDB Writer │ │ IPC Bridge (Python) │
└────────┬─────────┘ │ Exponential Backoff │
│ └────────────────────────────┘
▼
┌─────────────────┐
│ Neural Perceptor │ TCN (3 residual blocks)
│ INT8 Quantized │ Receptive field: 29 steps
│ 16,129 params │ Sliding window: 4096
└────────┬─────────┘
│
▼
┌─────────────────┐
│ Predicate │ confidence > 0.95 → AnomalyDetected
│ Generator │ 0.75-0.95 → AnomalyWarning
│ (Translator) │ ≤ 0.75 → NominalOperation
└────────┬─────────┘
│
▼
┌─────────────────┐
│ Logic Engine │ Tree-Walk Evaluator (FOL)
│ ProofObject XAI │ SHA-256 cycle detection
│ ActionHook │ 100-iteration ceiling
│ Observer Pattern │ DuckDB WAL persistence
└────────┬─────────┘
│
▼
┌─────────────────┐
│ Tactical TUI │ Textual 8.x
│ Command Center │ Monokai-Cyber theme
│ Proof Tree View │ @work(thread=True)
└─────────────────┘
Every logical conclusion produces a machine-verifiable and human-readable proof tree:
[system-01-[SystemCompromised]->true]
⟵ Rule: escalation_chain
● cpu_load(core-2, 97.3%) [████████░░] 0.973
● mem_pressure(proc-412, 94.1%) [█████████░] 0.941
◐ latency_spike(ipc-bridge, 312ms) [███████░░░] 0.780
Proof trees are generated by the recursive tree-walk evaluator and visualized in real-time in the Tactical Command Center. Every derivation traces back to its source rule and input facts — no black boxes.
| Requirement | Version | Notes |
|---|---|---|
| Python | 3.12+ | 3.14 recommended. Standard CPython — no Conda required. |
| Rust | Stable (1.75+) | For the Nexus-Bridge binary. Install via rustup.rs. |
| Linux | Kernel 5.15+ | Fedora 40+ or Ubuntu 22.04+ recommended. |
| Docker | 24+ | Optional. Only needed for containerized deployment. |
# 1. Clone
git clone https://github.com/idkBsy/aion-core.git && cd aion-core
# 2. Install (creates venv, installs deps, compiles Rust — no sudo)
make install
# 3. Launch the Tactical Command Center
make tuiTo run the full multi-process pipeline instead:
make run# Build the multi-stage image (Rust compile + Python slim runtime)
docker build -t aion-core:1.0.0-beta .
# Run the Tactical Command Center
docker run --rm -it aion-core:1.0.0-beta
# Or with Docker Compose (if available)
docker compose up --buildmake testThis runs the full verification suite — Python module imports and Rust compilation checks.
aion-core/
├── aion_core/
│ ├── logic/engine.py # Tree-walk evaluator, ProofObject, ActionHooks
│ ├── perception/
│ │ ├── inference.py # TCN with INT8 quantization
│ │ ├── translator.py # Neural → symbolic predicate mapping
│ │ └── processor.py # Telemetry stream processor
│ ├── shared/ipc/bridge.py # UDS client with backpressure handling
│ ├── storage/schema.sql # DuckDB schema v3
│ ├── nexus/src/main.rs # Rust IPC server + DuckDB writer
│ └── ui/tactical_monitor.py # Textual TUI command center
├── scripts/aion_orchestrator.py # Multi-process lifecycle manager
├── configs/ # System configuration
├── tests/ # Stress tests
├── Makefile # Build system (install/run/test/purge)
├── Dockerfile # Multi-stage container build
├── pyproject.toml # PEP 621 package metadata
└── docs/TECHNICAL_SPECS.md # Full technical specifications
AION-CORE respects your system. To completely remove all generated artifacts — the virtual environment, compiled Rust binaries, databases, logs, runtime sockets, and cached data:
make purgeAfter make purge, the repository is identical to a fresh git clone. No files are left outside the project directory. No system-level packages are affected.
To also remove the source code itself:
cd .. && rm -rf aion-coreThis is a v1.0.0-Beta release. The core inference pipeline is stable and verified under sustained load, but we are actively seeking:
- Security audits of the nonce-based IPC handshake protocol
- Performance profiling on diverse x86-64 hardware (Intel, AMD Zen 3/4/5)
- Reasoning correctness review of the tree-walk FOL evaluator
- Edge deployment reports from industrial and embedded environments
If you are a systems engineer, AI researcher, or security professional — your review matters. See CONTRIBUTING.md for guidelines.
MIT License. See LICENSE for details.
Engineered for the edge. Verified on real hardware. Auditable by design.