Kevin Ruschman
I architect local-first AI infrastructure and deterministic control planes—where language models act as interchangeable compute samplers over PostgreSQL ACID state, sandboxed verification, and multi-family bare-metal GPU clusters.
⚡ The 2026 Sovereign AI Tech Stack: Multi-Family GPUs, 3-Tier MCP Substrates, @krusch/toolkit & Closed-Loop Distillation
Why we inverted the conventional cloud-wrapper AI stack—treating language models as stateless compute samplers governed by bare-metal multi-family GPUs, relational PostgreSQL 16 state planes, a zero-bloat shared monorepo toolkit, and autonomous QLoRA self-distillation:
- Unified 1-Command Installer (
krusch-stack): Runnpx krusch-stack initordocker compose up -dto wire all 7 pillars and 39 annotated MCP tools across Claude Code, Cursor, Windsurf, and Antigravity. - Pillar I · Multi-Family 5-GPU + 96GB G4 Burst:
Qwen3-30B-MoE(124.2 tok/s) audited by orthogonalGemma 4&Hermes 3Referees + on-demand 96GB Blackwell G4 (gpt-oss:120b). - Pillar II · 7-Server MCP Ecosystem:
krusch-context-mcp,krusch-git,krusch-fs-mcp(8-node SSH page trees),krusch-harness(2PC),Gateway,Frontend, andG-Krusch. - Pillar III–V ·
@krusch/toolkit, Jean SRE & Open-Weights QLoRA Flywheel: Node 22 ESM & Python 3.12 runtime + 24/7 Jean SRE sweeps across 88 repos distilling 17,899 test-gated SFT rows (sovereign-code-audit-sft) into our published 120B Teacher and 30B Student QLoRA adapters.
The 5-Layer Sovereign AI Tech Stack
How multi-family bare-metal GPU routing, 7-server MCP substrates, sandboxed 2PC harnesses, air-gapped document intelligence, and @krusch/toolkit + QLoRA self-distillation compose into a unified platform.
Microsecond Syntactic Gating, Neural Centroids & Multi-Family GPU Pooling
Eliminates the 500ms LLM "routing tax." Intercepts deterministic patterns on CPU in <15µs for $0.00, routes semantic intents via <50ms embedding centroids to a multi-family 5-GPU bare-metal pool (Qwen3-Coder-30B-MoE at 124.2 tok/s + Gemma 4 / Hermes 3 cross-family Referees), bursts on-demand to 96GB Blackwell G4 (gpt-oss:120b), and reserves frontier Gemini 4 Argon escalation strictly for tail reasoning and 3-viewport UI visual audits.
Stage-0 CPU syntactic classifier and exact-match LRU memoization table. Intercepts code fences, SQL, stack traces, and voice board intents in <10µs with zero token burn.
Dual-stage L1 fast-path + L2 neural centroid cascade router with logprob confidence gating and speculative hedging. Benchmarked at 80.72% on RouteWorks RouterArena.
5 bare-metal GPUs across Dual RTX 3060 (24GB), Dual RTX 2080 Ti (22GB NVLink), and 11GB Orchestrator + on-demand 96GB Blackwell G4 burst (120B QLoRA distillation) and @krusch/toolkit runtime.
Governed Episodic Memory, Git DAG / AST Graphs & Multi-Node Fleet Page Trees
Replaces flat sliding-window RAG with three specialized Model Context Protocol substrates backed by PostgreSQL 16 + pgvector HNSW and zero-Docker SQLite WAL. Separates invariant working memory (krusch-context-mcp), Git DAG & AST caller/callee graphs (krusch-git), and OS/fleet filesystem page memory (krusch-fs-mcp).
5-verb sovereign coding-agent working memory (retrieve, remember, revise, nudge, health) in ~350 prompt tokens. Closed write taxonomy, temporal decision lineage, and pre-commit invariant auditing.
Relational Git DAG and zero-dependency AST symbol indexer in PostgreSQL 16. Recursive multi-hop caller/callee CTEs, SQL Reciprocal Rank Fusion, and temporal decay (60% Recall@1).
OS filesystem & multi-node SSH fleet page memory powered by KruschNexus Library Mode. Indexes PDFs, DOCX, and /etc/systemd into SHA-256 drift-verified page trees with redacted .env keys.
ACID Diff Staging, Sandboxed Verification & Voice-First Daily Execution
Enforces hard transactional boundaries between probabilistic model outputs and physical side effects. Code agents stage patches into PostgreSQL tables for isolated container test verification before human-approved 2PC fsync apply; personal and SRE agents operate under deterministic Confirm-Before-Act gates.
Headless PostgreSQL state-machine harness and diff workbench. Stages file mutations in staged_diffs, runs Bubblewrap sandbox verification, and commits atomically via 2PC apply journals.
100% local-first personal AI assistant & daily execution PWA. Local faster-whisper voice dictation, Dual-Axis Priority Board (4 Lanes × 6 Pillars), and 16-tool <holodata> proxy + Skylight sync.
Swappable storage substrate bridging local SQLite/PostgreSQL with Polygres Cloud (pgContext + pgGraph) and 40-char SHA pinning with fail-closed air-gap enforcement.
Physical Citation Coordinates, Statutory Preemption DAGs & Contract Compliance Joins
Replaces naive cosine similarity in regulated legal, financial, and commercial workflows with physical coordinate preservation (pdf_page, printed_page, bbox, char_start..end), versioned statutory precedence graphs, and confirmed-edge contract amendment resolution.
7-parser-family layout-aware ingestion spine (Poppler TSV hierarchical bounding-box union, 100% held-out citation accuracy, 96.2% span precision) with parse-only, search-lite, and factory modes.
Sovereign legal intelligence engine enforcing two-pass proposition entailment (0.00% False Support Rate), temporal as_of_date preemption DAGs (Floor vs. Ceiling rules), and cryptographic purge.
Confirmed-edge commercial contract graph resolving MSA/SOW/Amendment overrides, unexecuted draft isolation, and "The Join" (contract slot vs. statutory floor) via a <450-token 5-verb Gateway MCP.
Zero-Dependency Shared Toolkits, 24/7 Jean SRE & Self-Distilling SFT Flywheel
Eliminates transitive framework bloat across 26 production services via unified zero-dependency Node.js/Python toolkits, an autonomous 24/7 SRE daemon auditing 86 targets on bare metal, and a closed-loop QLoRA pipeline converting verified execution traces into specialized local adapters.
Unified Node.js ESM & Python 3.12 foundations providing multimodal LLM routing, single-token logprob System-1 deciders (@krusch/toolkit/decide), Spec-First Dual-Zero-Finding audit gates, and PhysCaP Code-as-Policy verifiers.
Autonomous 3-Tier MCP SRE daemon sweeping 88 repositories across 11 checkpoints with pre-hydrated AST caller graphs, Phase 1.9 Adversarial Steel-Manning, and Cross-Family Referee convergence gates.
Distills unit-test-gated remediations and rejection-sampled trajectories (17,899 rows across 3 splits) through krusch-stack into open-weights 120B Teacher (native Blackwell 4-bit MXFP4) and 30B Student LoRA adapters on 96GB G4.
Production Local-First Infrastructure & Multi-Family GPU Plane
Self-hosted 8-node Linux fleet engineered for zero cloud telemetry leakage, dedicated 10GbE PostgreSQL/vector storage throughput, 100% GPU-resident multi-family inference, and on-demand 96GB Blackwell G4 cloud burst distillation.
Primary production database & vector plane hosting PostgreSQL 16 + pgvector (dedicated NVMe relational & HNSW storage), DBOS durable execution, and our non-Qwen cross-family Referee pool (gemma4:e4b tool/vision Executor + hermes3:latest).
High-throughput compute server pinning 100%-GPU Qwen3-Coder-30B-MoE (q8_0 KV cache) at 124.2 tok/s, autonomous 24/7 Jean SRE 86-target codebase sweeps, and hermetic container test verification with strict OS NVMe write protection.
Central orchestrator pinning 1,024-dim bge-large embeddings, qwen2.5-coder:7b (74.6 tok/s), and 16kHz faster-whisper ASR—plus on-demand 96GB RTX PRO 6000 Blackwell G4 burst running gpt-oss:120b (~117.7 tok/s) and Dual-Track QLoRA distillation.
.env secret redaction · Zero-Docker SQLite WAL fallback.
The Invariant Execution Lifecycle: Stage → Verify → Commit
How krusch and kd-Code prevent autonomous coding agents from corrupting git repositories or applying broken refactors.
The model plans and generates diffs directly into relational tables (staged_diffs). Zero unvetted file writes ever touch your physical working tree.
A shadow workspace runs automated test suites, typechecks, and linters in isolation. If a test fails, the staged turn aborts instantly without repo pollution.
Inspect side-by-side color-coded diffs via @pierre/diffs, caller/callee symbol graphs, and invariant nudges before authorizing disk modification.
Only on verified tests AND explicit human approval does the two-phase commit manager fsync changes to disk. Instant 1-click rollback preserves sanity.
Core Architectural Invariants
The non-negotiable systems rules governing every layer in the KruschDev ecosystem.
Deterministic State Managers
Never trust language models to police their own file writes or follow conversational rules. Enforce constraints in PostgreSQL ACID tables, AST parsers, and atomic two-phase commit journals.
Multi-Tier Routing Cascades
Don't burn a 500ms LLM call just to choose an LLM. Intercept structured syntax on CPU in <15µs for $0.00, escalate to sub-50ms neural centroids, and only query frontier models when necessary.
Air-Gapped Hardware Control
Run compute, vector indexes, and episodic memory on self-hosted bare-metal clusters. Privileged files, client discovery, and organizational memory never leak to third-party cloud APIs.
Technical Publications by Architectural Layer (20)
Reproducible architectural deep dives, empirical ablation benchmarks, and systems specifications.
The 2026 Sovereign Tech Stack, Closed-Loop Audit & QLoRA Distillation, and Operating Planes
End-to-end stack architecture, 5-GPU + 96GB G4 burst compute, 3-Tier MCP code audits, Dual-Track QLoRA self-distillation, and sub-15µs syntactic gates.
⚡ The 2026 Sovereign AI Tech Stack: Multi-Family GPUs, 3-Tier MCP Substrates, @krusch/toolkit & Closed-Loop Distillation
Complete end-to-end engineering blueprint of the KruschDev tech stack: 5 bare-metal GPUs (Qwen3-30B-MoE at 124.2 tok/s + Gemma 4 / Hermes 3 cross-family Referees), 96GB Blackwell G4 burst (120B), the 7-server MCP ecosystem, @krusch/toolkit zero-bloat Node 22 / Python 3.12 runtime, and dual-track QLoRA distillation across 17,899 test-gated SFT rows.
🧠 The Closed-Loop Audit & Distillation Pipeline: 3-Tier MCP Context Hydration, Cross-Family Referees & Dual-Track QLoRA
How Jean SRE sweeps 88 repositories across 11 checkpoints: pre-hydrating AST caller/callee graphs and working-memory invariants via 3-Tier MCPs, eliminating false positives via Phase 1.9 Adversarial Steel-Manning, enforcing a Dual-Zero-Finding Cross-Family Referee gate, and fine-tuning 120B Teacher (native Blackwell MXFP4) and 30B Student weights on 17,899 test-verified, rejection-sampled SFT trajectories.
Read Audit & QLoRA Pipeline Paper →⚡ Multi-Tier Cascade Routing: Slashing Enterprise Inference Budgets by 60–80%
Systems architecture deep dive into krusch-cascade-router (benchmarked on RouteWorks RouterArena at 80.72% accuracy and $0.21/1K cost), krusch-pre-router (<15µs CPU gate, $0.00 routing tax), Stage-1 neural centroids (<50ms cosine routing), and speculative parallel hedging.
⚡ Postgres as the State Plane: Why Side Effects Require a Transaction Manager
A language model is a probabilistic sampler; side effects require a transaction manager. How krusch (coding harness), krusch-pre-router, krusch-cascade-router, and krusch-context-mcp unify into an invariant-gated developer control plane.
🚀 Local-First Core, Hybrid Cloud Elasticity: Decoupling Agent Memory
Decoupling AI coding agent working memory into managed PostgreSQL (pgGraph + HNSW) and optional cloud embeddings for zero VRAM load and global context while keeping file writes strictly sovereign.
Read Hybrid Elasticity Paper →Agent Working Memory, Git DAG / AST Code Graphs & OS Filesystem Substrates
The 5-verb MCP discipline, relational AST symbol indexing, multi-node SSH fleet page trees, and swappable Postgres/SQLite drives.
🗂️ krusch-fs-mcp: OS Filesystem Page Memory, SHA-256 Drift Detection & Multi-Node Fleet Indexing
Why coding and SRE agents need a dedicated OS & fleet filesystem memory substrate. Turning unstructured PDFs, DOCX, systemd units (/etc/systemd/system), and /etc/fstab across multi-node SSH server fleets into layout-true page trees with SHA-256 drift-verified PageMemory annotations.
🌳 krusch-git: Git DAG Indexing, Relational AST Symbols & Hybrid Recency Search
Why grep and flat vector RAG fail autonomous coding agents. Git DAG objects in PostgreSQL 16 + pgvector, zero-dependency AST lexing, recursive multi-hop caller/callee CTEs, exponential temporal decay (e-0.01t), and 60% Recall@1 hybrid search.
Read krusch-git Architecture →🧠 Beyond Flat Vector RAG: What Makes krusch-context-mcp Special
From tool overload to the radical 5-verb contract (~350 prompt tokens). Deep dive into krusch-context-mcp v1.8.0 (governed episodic memory, closed taxonomy, SQLite-first) and the architectural decoupling of codebase RAG into krusch-git.
💾 Swappable Substrates: Powering Agent Memory & Codebase Graphs with Polygres
Why AI coding agents need ACID decision logs and relational AST symbol graphs—and how swappable storage drives let you run locally on SQLite/Postgres or on Polygres Cloud (pgContext + pgGraph) without changing agent tools.
⚡ Sovereign Context & Safe Mutation Architecture for Coding Agents
Decoupling tool density, stratified λ-decay, declarative steering nuggets, and 2026 Streamable HTTP transport across enterprise PostgreSQL 16 + pgvector deployments.
Read Enterprise MCP Paper →⚡ Architecting Code-Agent Retrieval & Memory: Beyond Naive Vector Search
Why sliding-window RAG fails on codebases. Single-store PostgreSQL 16 + pgvector HNSW, structural symbol extraction, SQL Reciprocal Rank Fusion (RRF), dependency graph walks, and deterministic token budget packing.
Read Retrieval Benchmark Paper →Transactional Coding Harnesses & Sovereign Daily Execution
Pre-commit diff staging, container sandbox verification, 2PC apply journals, and local-first voice-driven agentic control.
🛡️ The Krusch Coding Harness: Why Autonomous Code Agents Require a Transaction Manager, Not a Prompt
Why unconstrained file writing breaks coding agents. Systems deep dive into krusch: pre-commit SHA-256 diff staging, Bubblewrap container isolation, storage-engine 2PC apply journals, row-locked catalog FSMs, and Modular RSI failure attribution.
🛡️ Introducing Krusch Companion: A Sovereign, Voice-First Personal AI Assistant & Execution Engine
Complete architectural tour of krusch-companion: local 16kHz faster-whisper Voice-to-Text, Dual-Axis Priority Board (4 Execution Lanes × 6 Life Pillars), 16-tool <holodata> proxy with Confirm-Before-Act gates, and SQLite WAL temporal fact superseding.
☁️ Introducing G-Krusch: A Sovereign Google Workspace Hub, Hybrid Drive RAG & MCP Bridge
Complete architectural deep dive into G-Krusch: cloud-synced agent.md steering, 3-tier 1,024-dim semantic + SQLite FTS5 BM25 Drive RAG, 3-tier PDF extraction, 12 MCP tools, and NIST AES-256-GCM security hardening.
Air-Gapped Document Ingestion, Vector Geometry & Precedence Graphs
Layout-true coordinate spines, statutory preemption DAGs, confirmed-edge contract graphs, and certified rulebooks.
📦 Authority Packs: Certified Rulebooks for Enterprise AI — Sovereign Domain Scoping vs. Vector Bleed
How bounded, versioned rulebooks (Jurisdiction Packs, Standards Packs, Playbook Packs) enforce O(1) token budgets, pre-extracted numeric slots, and physical citation truth across law, finance (ASC 606), and enterprise contracts.
Read Authority Packs Whitepaper →💼 Why Semantic Similarity Isn't Governing Precedence: What Makes KruschBiz Different From Generic RAG
Systems architecture deep dive into KruschBiz (v0.8.0): confirmed-edge precedence graph resolver, unexecuted draft isolation, materialized effective slots, The Join (contract vs. statute compliance engine), and physical citation spine coordinates (INV-11).
Read KruschBiz Architecture →⚖️ Why We Built KruschLaw: Local-First Legal RAG & Statutory Precedence
Why generalist RAG fails in statutory law. 0.00% False Support Rate on labeled golden benchmarks, versioned statutory precedence graphs (resolve_controlling_law with as_of_date), tenant defense deadlines, and cryptographic purge.
⚖️ Citations Die in Local RAG: Why We Built KruschNexus and What It's For
Why arbitrary token slicing destroys document citations. 7-parser-family held-out evaluation (100% citation accuracy, 96.2% span precision), page truth coordinate fidelity (pdf_page vs printed_page), and 4-stage retrieval ablation.
⚖️ The Sovereign Triad: Unifying Document Ingestion, Statutory Graphs & Working Memory
How KruschNexus (layout-true ingestion), KruschLaw (statutory authority & assertion grounding), KruschBiz (contract graphs), and KruschContext MCP create a self-auditing intelligence substrate.
Read Sovereign Triad Essay →⚡ The Ingestion Imperative: Why Retrieval Quality Is Bounded Before the Model Reads a Word
Why wrong retrieval is the dominant root cause of enterprise AI failure. Embedding space geometry (measured negation and numeric limits), parser contracts, citation spines, and how structured fixes fail.
Read Systems Architecture Note →