# Built a self-hosted local AI control plane that fits models to your actual hardware and workload. Runs llama.cpp, image, audio & ONNX workloads, benchmarks, auto-optimizes, requantizes, manages power, catches regressions, supports MCP/Hermes and scales across multiple GPU boxes. — retained record

> Retained reddit record from reddit:LocalLLaMA.

Canonical: https://highsignal.app/data/records/13e7f04377bb1af4

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:LocalLLaMA)  published 2026-09-25 17:15 ingested 2026-09-26 02:38

[original source ↗](https://www.reddit.com/r/LocalLLaMA/comments/1wq23dh/built_a_selfhosted_local_ai_control_plane_that/)

## retained text



```
**M**y deep research and understand indicates this project is unrivaled and is an island in on itself, not replacing anything, and complimenting most consumer/smb builds.

LexiPanel is my self-hosted control plane for local AI. I built it because I wanted the machine itself to be understandable, measurable and tunable instead of hiding everything behind presets. Yes, it was heavily vibe-coded, it’s named after my kid “Panel,” and I built it for my own homelab first.

The core idea now is simple: **fit AI to the hardware and workload, don’t just launch it.**

What it does now:

* Runs multiple independent llama.cpp, stable-diffusion.cpp, audio.cpp, Camelid and ONNX Runtime instances from one browser
* CPU/GPU/NPU support, including ONNX paths for AMD Ryzen AI, Intel and Qualcomm NPUs
* 220+ explained controls, plus passthrough access to flags exposed by the active llama.cpp build
* Shows exact launch command/env, warnings, VRAM/RAM estimates and refusal reasons before start
* Reads GGUF metadata, accounts for already-resident workloads and prevents unsafe launches
* Measures long-context decode behavior instead of treating one tok/s number as the whole story
* Benchmarks coding and agent workloads and compares configs/models against the workload you actually run
* Auto-fit learns idle windows, tests safe changes, checks them against later real traffic and rolls back regressions
* Fit can benchmark quant formats on your actual cards, create tensor-level requant plans to a real VRAM budget, build them and verify the result
* GPU tuning measures speed, thermals, power and tokens/joule. Supported AMD tuning can auto-revert unstable settings
* Power profiles cover CPU, PCIe/NVMe, GPU caps/fans, watchdog behavior and PSU/UPS budgeting
* OpenAI-compatible gateway with users, API keys, quotas, model restrictions and usage accounting
* Fleet mode: multiple LexiPanel boxes report into one primary, and running models can be shared through one gateway with basic replica selection/failover
* 28 MCP tools for status, models, launch plans, benchmarks, optimization, power/GPU state, diagnostics and more
* Hermes Agent compatibility/config generation
* Built-in llama.cpp Web UI integration
* Resumable HF downloads, engine build management, crash forensics, diagnostics, file manager, web terminal and backups
* Graph Gauntlet is still there because staring at charts gets old

The backend is still deliberately boring: Python stdlib only, no pip application deps, no Docker, no database, no frontend build system. State is files + systemd.

The part I think is different is the loop:  
**discover → fit → optimize → validate → operate → learn → adapt**

It’s not trying to replace Open WebUI, Ollama, GPUStack, LocalAI, vLLM, etc. The goal is to sit underneath apps and agents and make a local AI box, or a small mismatched fleet, run as well, safely and transparently as the hardware allows.

Still refining it. Constructive criticism, edge cases and good ideas are very welcome.

[https://github.com/W61k3r/LexiPanel](https://github.com/W61k3r/LexiPanel)
```



document fetched 2026-09-26 00:41 · canonical https://reddit.com/r/LocalLLaMA/comments/1wq23dh/built_a_selfhosted_local_ai_control_plane_that
