AI-assisted adaptive computer control layer for heterogeneous PCs
Status: Proprietary engineering prototype Current generation: AICore V4 / workspace version 0.4.0 Primary implementation: Rust Target platforms: Windows and Linux Source availability: Proprietary — core implementation is not publicly distributed
AICore is an experimental computer control layer that sits conceptually between applications and operating-system / hardware resource interfaces. It combines system telemetry, workload context, application task intent, historical information, and optional local AI inference to produce validated, observable, and reversible resource-control policies.
AICore is not a replacement operating system, a chatbot, or a collection of fixed "PC optimization" switches. The project explores whether a local control plane can help increasingly heterogeneous computers coordinate resources around the workload that is actually being executed.
Modern PCs increasingly combine:
- CPU compute
- integrated and discrete GPUs
- NPUs and other AI accelerators
- shared and dedicated memory
- multiple power states
- thermal and battery constraints
- interactive, background, rendering, compilation, gaming, and AI workloads
Resource decisions are distributed across applications, operating systems, runtimes, drivers, and vendor-specific interfaces. AICore explores an additional coordination layer that can reason about workload context while preserving deterministic validation and platform control boundaries.
flowchart LR
O[Observe] --> U[Understand]
U --> P[Predict]
P --> D[Decide]
D --> V[Validate]
V --> E[Execute]
E --> M[Measure / Verify]
M --> L[Learn]
L --> O
AI is deliberately not given direct privileged control:
flowchart LR
AI[AI / Prediction Proposal] --> POLICY[Resource Policy]
POLICY --> VALIDATOR[Policy Validator]
VALIDATOR --> BIND[Capability / Runtime Binding]
BIND --> EXEC[Platform Executor]
EXEC --> READBACK[Readback / Verification]
READBACK --> OS[Operating System / Hardware]
Unsupported, stale, invalid, or failed decisions can be rejected, degraded, rolled back, or moved into a safe operating path.
flowchart TB
APP[Applications / User Intent]
TASK[Workload Context / Task Contracts]
CORE[AICore Control Plane]
OS[Operating System]
HW[CPU / GPU / NPU / Memory / Power]
APP --> TASK
TASK --> CORE
CORE --> OS
OS --> HW
AICore does not replace the operating system, kernel, GPU/NPU firmware, vendor drivers, or application business logic.
The private V4 implementation currently contains engineering work in the following areas:
- adaptive runtime control loop
- workload and context representation
- policy generation, resolution, and validation
- Windows and Linux platform adapters
- process priority and CPU-affinity control paths
- power-profile integration
- GPU telemetry and capability-gated hardware-control primitives
- NPU capability and routing abstractions
- optional AI-assisted policy proposals
- optional local LLM intent interpretation
- application/task contracts
- L0 / L1 / L2 compatibility tiers
- execution readback and post-condition verification
- rollback, degraded operation, and SafeMode concepts
- local IPC
- plugin architecture and trust controls
- historical memory / persistence infrastructure
- CLI and local telemetry dashboard
- model mode and captured-fixture platform simulation
- automated engineering verification infrastructure
See Current Status for the important distinction between implemented architecture, verified engineering behavior, and capabilities that are not yet proven on real heterogeneous hardware.
AICore currently has no public cross-hardware performance benchmark dataset. This repository therefore does not claim that AICore:
- increases gaming FPS
- reduces compilation time
- improves AI inference throughput
- extends battery life
- reduces energy consumption
- improves thermals
- universally controls arbitrary GPUs or NPUs
- replaces the Windows or Linux scheduler
Real workload and cross-hardware validation is the next major stage of the project.
AICore uses three independent compatibility tiers:
The tiers communicate through shared contracts rather than depending directly on each other's implementation.
AICore is being developed as proprietary technology. This public repository exists to document the project's purpose, architecture, engineering status, and development direction without distributing the core source code, private models, platform-control implementation, internal test infrastructure, or proprietary technical assets.
This is a technical showcase repository, not the AICore source repository.
- Project Overview
- Public Architecture
- Capabilities
- Current Status & Evidence Boundary
- Safety & Control Principles
- Roadmap
- Technical FAQ
Technical feedback is especially welcome from people working in:
- operating systems
- performance engineering
- heterogeneous computing
- AI PCs
- power and thermal management
- GPU / NPU runtimes
- local AI infrastructure
- systems programming
For technical/partnership/licensing inquiries: kenny98929974@gmail.com
AICore is a private engineering prototype. Public documentation describes the project but does not grant access to or rights in the private implementation.