// THREAT LAB RESEARCH BY JOE BRINKLEY (THE BLIND HACKER)

Intel & Writeups

Tactical guides, vulnerability deep dives, and AI-driven threat emulation operations from The Blind Hacker & NextGenRedTeam.

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

Strata on the ZimaCube Pro: Why Q6 and 6 Cores Beat Q8 and Dense Models

Benchmarking the Strata MoE engine on the ZimaCube Pro with 42GB RAM: Q6 vs. Q8 math, CPU core scaling, and why 35B MoE beats 8B dense models.

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

Hacking by Ear at 500 WPM: How Screen Readers and Custom CLI Tooling Outpace Visual IDEs in Offensive Research

Auditing code at 550 words per minute while using full-time screen zoom is an unfair offensive advantage. Here is the terminal playbook from my talk Hacking While Blind, showing how combining screen magnification and speech synthesizers beats visual IDEs.

READ_THREAD >
// 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 >