// THREAT LAB RESEARCH

Intel & Writeups

Tactical guides, vulnerability deep dives, and thoughts on AI-driven threat emulation operations.

// 2026-07-10 // BY JOE B. THE BLIND HACKER

Experimental Rebuild Tuning: llama.cpp MoE Memory Gains and Dense Regressions

We compiled and tested a custom llama.cpp fork on our RTX node. Here is how it optimized Mixture of Experts (MoE) memory, why it fumbled dense model speeds, and why we rolled back.

READ_THREAD >
// 2026-07-09 // BY JOE B. THE BLIND HACKER

Building a Private AI Research Lab: Bridging LiteLLM and SearXNG on NextGenPVE

How we containerized and bridged SearXNG and LiteLLM in LXC 205 on NextGenPVE for privacy-respecting threat intelligence gathering and local AI orchestration.

READ_THREAD >
// 2026-07-03 // BY JOE B. THE BLIND HACKER

Deep Benchmarks v7: Pushing NextGenPVE to the Limit

Reviewing the latest local LLM benchmarks across NextGenPVE-RTX and the new NextGenPVE-NPU hardware.

READ_THREAD >
// 2026-07-02 // BY JOE B. THE BLIND HACKER

Massive Environment Overhaul: Brain-RTX Hyper-Optimization & Benchmark Results

How I heavily modified the GPU daemon on my local rig to handle massive 12k+ token agentic context windows without choking.

READ_THREAD >
// 2026-06-28 // BY JOE B. THE BLIND HACKER

The NPU Journey Part 4: Conquering the Final Boss (Strict JSONs, CMM Boot Windows, and Gateways)

Resolving strict post_config type checks, handling the 65-second CMM boot window, and building a LiteLLM translation layer for unified edge NPU inference.

READ_THREAD >
// 2026-06-27 // BY JOE B. THE BLIND HACKER

The NPU Journey Part 3: Night Shift Compilation Breakthroughs (AppArmor, LXC Ghost Memory)

Resolving nested container virtualization blocks, bypassing AppArmor security confinement, and clearing ghost memory traps during our high-throughput compilation sprint on the AX8850.

READ_THREAD >
// 2026-06-26 // BY JOE B. THE BLIND HACKER

The NPU Journey Part 2: The True Guide to Deploying LLMs on the Axera AX8850

The definitive, step-by-step technical guide to native LLM deployment on the AX8850 NPU via PCIe passthrough inside an unprivileged LXC container.

READ_THREAD >
// 2026-06-25 // BY JOE B. THE BLIND HACKER

The NPU Journey Part 1: Taming the Axera AX8850 (And Why We Reverse-Engineered Everything for Nothing)

Admitting our over-engineering mistakes: how broken vendor paths and JSON parser bugs led us to reverse engineer everything for nothing, and the reality of taming the Axera AX8850 NPU.

READ_THREAD >
// 2026-06-24 // BY JOE B. THE BLIND HACKER

ReThink: Bypassing DKMS and Virtualizing the AX8850 NPU in NextGenPVE LXC

How we decoupled the Axera AX8850 NPU from bare-metal, resolved NextGenPVE LXC DKMS compiler conflicts, and cleared stale CMM allocations to host localized reasoning LLMs.

READ_THREAD >
// 2026-06-23 // BY JOE B. THE BLIND HACKER

Ultimate Guide: Zero-Copy Inference on the AX8850 NPU

How to bypass Radxa's Python CPU bottlenecks, compile a native C++ OpenAI server, and achieve stable zero-copy inference on the AX8850 NPU.

READ_THREAD >
// 2026-06-22 // BY JOE B. THE BLIND HACKER

Conquering the Silicon: Building a Custom 'Ollama' Orchestrator for the AX8850 NPU (Part II)

How we bypassed broken vendor API servers, solved logit collapse with a physical SRAM context-window hack, and built an on-the-fly model hot-swapping daemon.

READ_THREAD >
// 2026-06-21 // BY JOE B. THE BLIND HACKER

Taming the Edge: Bypassing Axera AX8850 NPU Compiler Constraints

A technical deep-dive into reverse-engineering the Pulsar2 compiler, patching PyArmor memory classes in-flight, and executing local LLMs on the Radxa AX-M1 NPU.

READ_THREAD >
// 2026-06-19 // BY JOE B. THE BLIND HACKER

Benchmarking NextGenRedPVE: Running Local Offensive AI Agents on Proxmox

How we tested, why we tested, and what we learned benchmarking local abliterated LLMs for red team operations on our NextGenRedPVE cluster.

READ_THREAD >
// 2026-06-19 // BY JOE B. THE BLIND HACKER

Reasoning Models vs. Frontier Models in Offensive Security Benchmarking

An in-depth evaluation of local reasoning models versus commercial frontier models, alignment and safety refusal bottlenecks, and agent frameworks like Swarm-AI in offensive security benchmarking.

READ_THREAD >
// 2026-06-12 // BY JOE B. THE BLIND HACKER

Testing the Gates: Why You Must Emulate Authentication Failures

Why static rule validation fails, and how actively emulating login failures across Windows and Linux reveals hidden gaps in security logging.

READ_THREAD >
// 2026-06-11 // BY JOE B. THE BLIND HACKER

Demystifying Detection: Emulating Windows Event ID 4625 & SSH Login Failures

A deep dive into building programmatic triggers for Windows SMB/NTLM and Linux SSH authentication failures to validate SIEM alerts and detection pipelines.

READ_THREAD >
// 2026-06-09 // BY JOE B. THE BLIND HACKER

Rescuing Abandoned IoT: How I Built JoeBro to Control My Smart Table

When manufacturers abandon their mobile apps, expensive smart hardware turns into a brick. Here is how I reverse-engineered the Ayla Networks API to build a zero-backend PWA.

READ_THREAD >