Kevin Ruschman — AI Infrastructure Engineer

OPEN-SOURCE ENGINEERING PORTFOLIO · @KRUSCHDEV

Core Open-Source Infrastructure: Agent Memory, Code Verification & Crash-Recoverable Execution

Three complementary open-source substrates addressing the primary reliability failure modes of autonomous coding agents: krusch-context-mcp governs the reliability of an agent's persistent memory and architectural invariants, while @krusch/toolkit and krusch-coding-harness govern the reliability and safety of the code and side effects it produces.

SUBSTRATE 01 · PERSISTENT WORKING MEMORY & INVARIANT LINEAGE v2.0.0 · 82★ GitHub · 7 Forks · 86/mo npm · 144/144 Tests

krusch-context-mcp — Zero-LLM Episodic Memory & SHA-256 Drift-Guarded Invariants

Problem:: Long-horizon coding agents lose architectural invariants across sessions, retrieve stale or contradictory context, or burn LLM tokens on lossy summarization.
Architecture:: Deterministic $0.00 zero-LLM 256/32-token Raw-RAG + local 1024d snowflake-arctic-embed2 + SQLite Porter-FTS5 4-Way Reciprocal Rank Fusion + INV-12 SHA-256 line-span drift detection + 2-hop Gram-Schmidt residual bridge.
Implementation:: Node.js 22 node:sqlite WAL (0o444 read-only benchmark stores, optional PostgreSQL 16 + pgvector backend) exposing 5 canonical MCP verbs (retrieve, remember, revise, nudge, health in ~350 schema tokens).
Verification:: 144/144 automated Node tests + 5/5 BlindMappingGuard (LoCoMo) & 10/10 BEAM SHA-256 zero-leakage verifiers + cross-family T=0 evaluation judges.
Results:: 90.26% accuracy & 95.77% dia_id recall across 1,540 ACL 2024 Snap LoCoMo probes at $0.00 ingest; 91.17% (547/600 @ $24.54) uploaded dolphinbench.ai submission (UUID c047b063, queued awaiting leaderboard acceptance; exceeds current 70.67% published entry); self-run 600-task evaluations with published audit logs at 90.67% (544/600 + Grounded v0.3, 90.50% on Riley), 81.50% @ $1.35 (71.1x cheaper than Mem0 on identical GPT 5.6 Luna), 57.33% (344/600 Wave-6 Gemma 4 31B @ $0.00, top open-weights self-run result; 54.17% queued stock UUID 288671ad), and 98.33% Oracle@28; 2,000/2,000 ICLR 2026 BEAM up to 10M tokens (93.00% IE).
Limitations:: Zero-LLM Raw-RAG misses 1.67% (10/600) of tasks requiring implicit multi-turn synthesis with zero lexical or dense-vector overlap; local node:sqlite WAL targets single-host agent sessions rather than distributed multi-writer clusters (addressed via the PostgreSQL 16 adapter).
Source:: GitHub (kruschdev/krusch-context-mcp) → · npm (krusch-context-mcp) → · Architecture Deep Dive →

SUBSTRATE 02 · RELEASE-GATED RUNTIME BRICKS & DETERMINISTIC STATIC GATES v1.8.1 JS/TS · v1.6.0 Python · 39 Bricks · 16 Static/AST Detectors

@krusch/toolkit & krusch_toolkit — Pre-Audited Runtime Bricks & Sub-Millisecond Slop-Breaker

Problem:: Coding agents repeatedly generate subtly broken boilerplate—DNS-rebinding SSRF regexes, non-constant-time webhook checks, unclamped ORM pagination, hardcoded JWT fallbacks, and un-aborted fetches.
Architecture:: Pre-audited runtime "Lego bricks" (39 modules, 64 .d.ts subpaths, 7 blueprints) paired with a deterministic <1ms comment/string-masked static & structural auditBoilerplateText Slop-Breaker gate (16 rules)—deliberately using zero-cost deterministic static analysis instead of slow, probabilistic LLM linting.
Implementation:: Node 22 ESM & Python 3.12 libraries providing connect-time DNS-pinned safeFetch, timingSafeEqual HMAC verification, 409/422 idempotency locks, SHA-256 hash-chained audit logs, zero-node:* RBAC/IDOR guards, and <15µs (<25µs ceiling) pure-CPU Stage-0 cascade circuit breakers.
Verification:: 141/141 Node tests + 201/201 pytest tests + 0/212 release-hygiene checks + live third-party OSS validation on OWASP/NodeGoat, node-express-realworld-example-app, and stripe-samples/accept-a-payment (104/104 clean compliance across internal repos).
Results:: Catches real SSRF, auth-secret fallback, unclamped pagination, and unsafe YAML/webhook anti-patterns in <1ms at $0.00 compute cost; paired Okapi BM25 deferred MCP loading (krusch-stack v1.1) cuts upfront tool-schema bytes -68.5% (+6.40 pp BFCL v3 accuracy).
Limitations:: Structural/AST rules target deterministic vulnerability and boilerplate classes (16 rules), not arbitrary domain-logic bugs; dynamic eval or cross-service taint requires sandboxed runtime tests and multi-family code review (runThreeFamilyRefereeAudit).
Source:: GitHub (kruschdev/toolkit) → · GitHub (kruschdev/krusch-stack) → · 39-Brick Architecture Paper →

SUBSTRATE 03 · SANDBOXED STAGING & CRASH-RECOVERABLE EXECUTION v0.3 · 116/116 + 7/7 Tests · Crash-Recoverable 2PC

krusch-coding-harness & krusch-grounded-harness — Write-Ahead Apply Journals & Turn-0 Grounding

Problem:: Unconstrained coding agents overwrite dirty working trees, spin in duplicate failing tool calls, execute prompt-injected shell commands, or leave partial file writes on mid-commit crash.
Architecture:: Import-frozen Object.freeze policy floors + Bubblewrap (bwrap) sandboxes + <150ms Turn-0 schema/hazard grounding + PostgreSQL 16 write-ahead apply journaling paired with pre-commit SHA-256 file-drift guards, POSIX atomic renameSync/fsync replacement, and startup crash reconciliation.
Implementation:: Deterministic state machine (PENDING → VERIFYING → APPROVED → APPLYING → APPLIED / RECOVERED) with deterministic mid-apply crash-injection hooks (SIGKILL after the first rename via KRUSCH_TEST_HOOK_PAUSE_AFTER_FIRST_RENAME, then recoverInFlightApplies()), comment-normalized spin-loop memoization (INV-GH-04), and 0-turn defect-only output gates (INV-GH-06).
Verification:: 116/116 krusch-coding-harness tests (including interrupted-apply crash recovery & reconciliation) + 7/7 krusch-grounded-harness tests + 1,046 ETH SpyLab AgentDojo security episodes + 225 Aider Polyglot exercises + 120 adyen/DABstep episodes.
Results:: 0.00% Attack Success Rate (0/1,046 AgentDojo prompt-injection episodes), <32ms local write-ahead journal + atomic swap overhead, 51.56% Aider Polyglot (2.64x lift on open-weights), 90.0% DABstep @ $0.81 (-74.5% cost, 2.54x faster), and -95.2% (42 → 2) duplicate MCP calls.
Limitations:: Terminology: "2PC" is this project's name for a journaled, crash-recoverable multi-file apply protocol (PostgreSQL write-ahead intent + POSIX atomic per-file replacement), not classic distributed two-phase commit with transactional participants. Each file swap is atomic, but a multi-file batch is not atomically visible: another process can observe a partly-applied batch until it completes or recovery rolls it back. PostgreSQL ACID does not natively span POSIX filesystems—write-ahead journaling + renameSync + startup reconciliation recovers mid-commit process crashes, but an uncoordinated external OS process mutating the same file in the sub-millisecond window between the SHA-256 pre-check and renameSync can still race without container/worktree isolation.
Source:: GitHub (kruschdev/krusch-coding-harness) → · GitHub (kruschdev/grounded-harness) → · Coding Harness Paper →

Recorded run (15 s): the real krusch-coding-harness code against PostgreSQL — applyDiffBatch() is killed with SIGKILL right after the first file rename, leaving a torn state, and recoverInFlightApplies() restores both files and resets the rows to PENDING. Source: scripts/demo-crash-recovery.mjs (same path as test/integration/crash-smoke.test.js) · raw output.

INTERACTIVE WALKTHROUGH · CROSS-SESSION AGENT RELIABILITY

Interactive Trace: Persistent Memory, Static Gates & Crash-Recoverable 2PC

Step through a multi-session task to inspect how krusch-context-mcp, @krusch/toolkit, and krusch-coding-harness block stale line drift, catch SSRF boilerplate in <1ms, and recover cleanly from a mid-commit crash. Illustrative replay: function, table, and outcome names match the source; the recording above is the real run.

Simulate Mid-Commit Crash (SIGKILL)

krusch-context-mcp v2.0 · node:sqlite WAL VALID · SHA-256 PINNED

Session 1 records an architectural invariant anchored to exact file coordinates (src/public/assets/layman-mode.js#L21) with a SHA-256 line-span hash at $0.00 zero-LLM cost.

Agent Action / MCP Call

krusch_context_remember({
  category: "invariant",
  content: "Keep STORAGE_KEY pinned at line 21",
  provenance: { file: "src/public/assets/layman-mode.js", start_line: 21 }
})

Deterministic Gate Output

{
  "ok": true,
  "id": 152,
  "anchor": "layman-mode.js#L21",
  "sha256": "a4f9c2e8...81c2",
  "status": "VALID",
  "ingest_cost_usd": 0
}

ENGINEERING BACKGROUND · WHY I BUILD FOR FAILURE MODES

From Physical Operations & Field Diagnostics to Deterministic Agent Infrastructure

Before focusing full-time on AI infrastructure, I spent nine years (2014–2023) working in physical environments where symptoms rarely match root causes and mistakes carry immediate operational cost—executing electrical panel modifications, conduit runs, power budgeting, grounding, and structural carpentry in Southern Vermont; directing mobile field-diagnostic crews and logistics for the Wisconsin Bicycle Federation; and launching and operating a physical cafe in Aspen, Colorado from buildout through supply chain, POS systems, and staff training to first-year profitability (building on earlier leadership as an Eagle Scout directing a 9-person crew).

That background directly shaped how I architect AI systems today. In electrical and field engineering, you never trust an ungrounded load or assume the happy path holds under load—you install circuit breakers, isolate fault domains, and verify state with instruments before energizing a line. I treat language models the exact same way: use deterministic software (PostgreSQL write-ahead state, <15µs pure-CPU gates, <1ms static AST checks, and POSIX atomic renameSync journals) wherever conventional engineering solves the problem cleanly, and reserve probabilistic models strictly for bounded reasoning inside verifiable sandboxes.

SUPPORTING INFRASTRUCTURE

The Lab Behind the Three Projects

The flagship projects run on infrastructure I assembled and operate myself. This is the supporting layer, not the headline: one diagram, one table, and the full details folded below.

What leaves the lab (scope: the lab workflows documented on this site — benchmark runs, code-review audits, publishing): external services receive only public benchmark data and my own open-source code. No private or third-party customer data is used in these workflows. Projects that support optional frontier-model escalation (for example the cascade router) send prompts to that provider when escalation is enabled; the offline-capable reference designs run with it turned off.

Layer	Role	Main pieces
1 · Routing	Pick the cheapest model that can do the job	<15µs CPU pre-gate, cascade router, local GPU pool + optional cloud burst
2 · Memory & code knowledge	What the agent knows across sessions	`krusch-context-mcp` (decisions, invariants), `krusch-git` (code graphs), `krusch-fs` (OS files)
3 · Safe execution	What the agent is allowed to change	`krusch-coding-harness`: sandbox, tests, write-ahead journal, crash recovery
4 · Data	Durable state and search	PostgreSQL 16 + pgvector, SQLite for single-machine memory
5 · Feedback loop	Improve from verified outcomes	`@krusch/toolkit` bricks, maintenance daemon, fine-tuned open-weights adapters

Research Experiments prototypes, not products

KruschNexus — offline PDF reading with page-and-line citations
KruschLaw — statute lookup with point-in-time rule versions
KruschBiz — contract amendment and precedence tracking

Show full architecture details (5-layer blueprint, hardware topology, change lifecycle)

FLAGSHIP ENGINEERING MONOGRAPH · OCTOBER 2026

The 2026 Sovereign AI Tech Stack: Multi-Family GPUs, 3-Tier MCP Substrates, @krusch/toolkit & Closed-Loop Distillation

Why I inverted the conventional cloud-wrapper AI stack—treating language models as stateless compute samplers governed by bare-metal multi-family GPUs, relational PostgreSQL 16 write-ahead state planes, a zero-bloat shared monorepo toolkit, and autonomous QLoRA self-distillation:

Unified 1-Command Installer (krusch-stack): Run npx krusch-stack init --defer-tools or docker compose up -d (v1.1.0) to wire all 7 pillars, 39 annotated MCP tools via Okapi BM25 deferred schema loading (-68.5% upfront schema bytes), my Turn-0 Grounded Harness (v0.3), and my generalized 2PC Tool-Action Harness (INV-STACK-10) across Claude Code, Cursor, Windsurf, and Antigravity.
Pillar I · Multi-Family 5-GPU, 8K Arctic & 96GB G4 Burst: Qwen3-30B-MoE (124.2 tok/s) audited by orthogonal Gemma 4 & Hermes 3 Referees to eliminate single-family blind spots, paired with local 8K snowflake-arctic-embed2 embeddings and on-demand 96GB Blackwell G4 burst compute (gpt-oss:120b & gemma4:31b).
Pillar II · Orthogonal 3-Tier MCP & Precedence Substrates: Strictly separates episodic working memory and invariant lineage (krusch-context-mcp), relational Git DAG & AST caller/callee graphs (krusch-git), 8-node SSH OS page trees (krusch-fs-mcp), write-ahead 2PC diff staging (krusch-coding-harness), and layout-true legal/contract precedence engines (KruschNexus, KruschLaw, KruschBiz).
Pillar III–V · @krusch/toolkit, Raw-RAG, Jean SRE & QLoRA Flywheel: 39-brick Node 22 ESM (v1.8.1) & Python 3.12 (v1.6.0) substrates + 16 <1ms static Slop-Breaker rules power 24/7 Jean SRE sweeps across 104 repos—distilling 18,131 Zero-Leak SFT + DPO trajectories (sovereign-code-audit-sft) into published 31B Dense, 120B Teacher, 30B Student, and 8B Edge QLoRA+DPO adapters.

Read Full 2026 Tech Stack Blueprint → Cross-Stack Benchmark Comparison → Install krusch-stack (GitHub) → 🤗 Raw Audit Logs (49) →

The 2026 Sovereign AI Tech Stack Architecture Diagram

SYSTEMS ARCHITECTURE BLUEPRINT

The 5-Layer Sovereign AI Tech Stack

How multi-family bare-metal GPU routing, 7-server MCP substrates, sandboxed 2PC harnesses, offline-capable document intelligence, and @krusch/toolkit + QLoRA self-distillation compose into a unified platform.

LAYER 01 · COMPUTE, GPU FLEET & CASCADE ROUTING PLANE <15µs Stage-0 Gate · 0.7263 CI-Verified RouterArena

Microsecond Syntactic Gating, Neural Centroids & Multi-Family GPU Pooling

Eliminates the 500ms LLM "routing tax." Intercepts deterministic patterns in <15µs (<25µs ceiling) via an in-process pure-CPU Stage-0 syntactic/lexical gate prior to model inference for $0.00, routes semantic intents via 8K snowflake-arctic-embed2 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 & gemma4:31b), and reserves frontier Gemini 4 Argon escalation strictly for tail reasoning and 3-viewport UI visual audits.

krusch-pre-router npm v1.0

In-process pure-CPU Stage-0 syntactic/lexical classifier and exact-match LRU memoization table executed prior to model inference (<15µs typical, <25µs ceiling; <10µs exact-match hit). Intercepts code fences, SQL, stack traces, and voice board intents with zero token burn.

GitHub Repo → npm Package →

krusch-cascade-router npm v1.1 · 104 Tests

Dual-stage L1 pure-CPU Stage-0 syntactic/lexical gate (<15µs / <25µs ceiling prior to inference) + L2 1,024d Arctic centroid router with live SSE logprob/loop circuit breakers—dispatching each prompt to the lowest-cost capable tier before escalating (0.7263 CI-verified upstream submission on RouteWorks/RouterArena PR #169; full routing tables in whitepaper).

Read Whitepaper → GitHub → 🤗 HF Benchmarks →

Multi-Family GPU + G4 Burst 57GB+ Local · 96GB G4

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 & 31B dense open-weights evals) and @krusch/toolkit runtime.

2026 Tech Stack Paper → View Hardware Topology →

LAYER 02 · RELATIONAL STATE, WORKING MEMORY & STRUCTURAL GRAPHS 82★ · 3-Tier MCP Ecosystem

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).

krusch-context-mcp 82★ · npm v2.0.0

5-verb sovereign coding-agent working memory (retrieve, remember, revise, nudge, health) in ~350 schema tokens. Pairs $0.00 zero-LLM 256/32-token Raw-RAG + 4-Way Reciprocal Rank Fusion with explicit decision superseding and INV-12 SHA-256 line-span drift detection so stale architectural rules never silently poison new sessions.

Return on Memory Paper → Local AI Memory Study → BEAM 2,000/2,000 Paper → GitHub (82★) →

krusch-git npm v1.2.3 · 15ms AST DAG

Relational Git DAG, multi-language AST chunker (JS/TS/Py/Go/Rust/Java) & live import-activity analyzer in PostgreSQL 16 (15.25ms HNSW/GIN)—tracing inbound callers and outbound callees before an agent modifies public interfaces across repositories.

Read Architecture → GitHub Repo →

krusch-fs-mcp v0.3.1 · 8-Node Fleet

OS filesystem & multi-node SSH fleet page memory powered by KruschNexus Library Mode. Indexes PDFs, DOCX, and /etc/systemd into compact float32 vector blobs & SHA-256 drift-verified page trees.

Read Architecture → GitHub Repo →

LAYER 03 · TRANSACTIONAL EXECUTION HARNESS & SOVEREIGN CONTROL PLANE Write-Ahead 2PC · <32ms Journal+Swap

Write-Ahead Diff Staging, Policy Floors, Sandboxed Verification & Voice-First Daily Execution

Enforces hard deterministic boundaries between probabilistic model outputs and physical side effects. Code agents stage patches behind import-frozen policy floors and truncation breakers before committing via a PostgreSQL write-ahead apply journal paired with POSIX atomic renameSync/fsync replacement and pre-commit SHA-256 drift guards (<32ms local journal+swap overhead); personal and SRE agents operate under Confirm-Before-Act gates and inter-agent prompt sanitization.

krusch-coding-harness 2PC Harness · 116 Tests

PostgreSQL state-machine harness enforcing import-frozen policy floors, Turn-0 workspace schema/hazard grounding (krusch-grounded-harness v0.3), duplicate tool-call memoization, ephemeral Bubblewrap sandboxes, and crash-recoverable write-ahead apply journals paired with POSIX atomic renameSync/fsync replacement.

Read Harness Paper → GitHub Repo →

krusch-companion v1.2 · 73 Tests

100% local-first personal AI assistant & daily execution PWA. Local faster-whisper voice dictation, Dual-Axis Priority Board, 20-tool <holodata> proxy, 256/32-tok Raw-RAG recall & Skylight sync.

Read Playbook → GitHub Repo →

@krusch/polygres-connector v1.0 · Hybrid Sync

Swappable storage substrate bridging local SQLite/PostgreSQL with Polygres Cloud (pgContext + pgGraph) and 40-char SHA pinning with fail-closed air-gap enforcement.

Read Substrate Paper → GitHub →

LAYER 04 · AIR-GAPPED DOCUMENT INGESTION & PRECEDENCE INTELLIGENCE Citation Coordinates · Precedence DAGs

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.

KruschNexus v0.2.6 · 206 Tests

7-parser-family layout-aware ingestion spine pairing contextual section-path embeddings with a local mxbai-rerank-large-v2 cross-encoder—delivering exact page, bounding-box, and character coordinates to downstream legal and commercial engines without arbitrary token slicing.

Read KruschNexus Paper → Ingestion Geometry →

KruschLaw & Authority Packs v0.7.0 · Statutory DAGs

Sovereign legal intelligence engine enforcing two-pass proposition entailment against source statutory text, bounded Authority Packs preventing cross-jurisdiction vector bleed, temporal as_of_date preemption DAGs (Floor vs. Ceiling rules), and cryptographic purge.

Read KruschLaw Paper → Authority Packs (n=180) →

KruschBiz & Gateway MCP v0.8.0 · 200 Tests

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.

Read KruschBiz Paper → Reference Architecture →

LAYER 05 · ZERO-BLOAT RUNTIME, AUTONOMOUS SRE & DUAL-TRACK QLoRA DISTILLATION

Zero-Dependency Shared Toolkits, 24/7 Jean SRE & Self-Distilling SFT Flywheel

Eliminates transitive framework bloat across 28+ services via unified 39-brick zero-dependency Node.js 22 (v1.8.1) & Python 3.12 (v1.6) toolkits, an autonomous 24/7 SRE daemon auditing 104 repositories (Nov 2026) on bare metal, and a closed-loop QLoRA+DPO pipeline converting unit-test-verified remediations into open-weights adapters.

@krusch/toolkit & krusch_toolkit Zero-Dep Runtime

Unified Node.js 22 ESM & Python 3.12 foundations (39 release-gated bricks, 7 blueprints & 16 static Slop-Breaker rules) standardizing 8K snowflake-arctic-embed2 batching, zero-LLM 256/32-tok Raw-RAG, atomic idempotency, tamper-evident audit-log, zero-node:* rbac, HMAC pagination, and Cross-Family Referee gates.

35-Brick Lego Paper → Read Tech Stack Blueprint → PhysCaP & Gates →

Jean SRE & 11-Phase Audit 104 Targets · 24/7

Autonomous 3-Tier MCP SRE daemon sweeping 104 repositories (Nov 2026) across 11 checkpoints with pre-hydrated AST caller graphs, Phase 1.9 Adversarial Steel-Manning, and Cross-Family Referee convergence gates.

Read Audit & QLoRA Paper → GitHub (Jean SRE) →

Dual-Track QLoRA Flywheel 18,131 SFT+DPO · HF Live

Distills unit-test-gated remediations and rejection-sampled trajectories (18,131 rows across 7 splits) through krusch-stack into published open-weights LoRA+DPO adapters (31B Dense, 120B Teacher in Blackwell 4-bit MXFP4, 30B Student, and 8B Edge) that feed directly back into local routing tiers.

🤗 Dataset (18.1K) → 🤗 31B LoRA → 🤗 30B LoRA → 🤗 120B LoRA → 🤗 8B LoRA →

BARE-METAL CLUSTER TOPOLOGY

Local-First Lab 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.

Node-01 · State & Referee Host State & Non-Qwen Pool

Dual Xeon 40T · 80GB RAM · Dual RTX 3060 (24.5GB VRAM)

Primary lab database & vector plane hosting PostgreSQL 16 + pgvector (dedicated NVMe relational & HNSW storage), DBOS durable execution, secondary 8K snowflake-arctic-embed2, and my non-Qwen Referee pool (gemma4:e4b + hermes3:latest).

Node-02 · Heavy Compute 30B MoE & Jean SRE Host

Dual Xeon 40T · 64GB ECC · Dual RTX 2080 Ti (22.5GB NVLink)

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 104-target codebase sweeps, and hermetic container test verification with strict OS NVMe write protection.

Node-03 + 5 Edge & G4 Burst Orchestrator, Mesh & L2.5 Burst

RTX 2080 Ti (11.2GB) + 5 Fleet Nodes + 96GB Blackwell G4

Central orchestrator pinning 8K-ctx 1,024-dim snowflake-arctic-embed2 (89.17% R@1), 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.

Interconnect & Security Invariants: Dedicated 10GbE Direct Fabric between compute and PostgreSQL state nodes · Encrypted Tailscale mesh · Pre-transport .env secret redaction · Zero-Docker SQLite WAL fallback.

Read 2026 Tech Stack Blueprint → View Offline-Capable Reference Architecture →

PROOF OF INVARIANCE

The Invariant Execution Lifecycle: Stage → Verify → Commit

How krusch and kd-Code prevent autonomous coding agents from corrupting git repositories or applying broken refactors.

STEP 01

Stage in Postgres

ACID Isolation

The model plans and generates diffs directly into relational tables (staged_diffs). Zero unvetted file writes ever touch your physical working tree.

STEP 02

Sandboxed Verify

Ephemeral Runner

A shadow workspace runs automated test suites, typechecks, and linters in isolation. If a test fails, the staged turn aborts instantly without repo pollution.

STEP 03

AST & Diff Review

kd-Code Workbench

Inspect side-by-side color-coded diffs via @pierre/diffs, caller/callee symbol graphs, and invariant nudges before authorizing disk modification.

STEP 04

Write-Ahead Fsync Apply

<32ms Journal + Swap

Only on verified tests AND explicit human approval does a PostgreSQL write-ahead apply journal paired with POSIX atomic renameSync/fsync replacement and pre-commit SHA-256 drift guards swap changes onto disk (<32ms local journal+swap overhead) with 1-click rollback.

BENCHMARK EVIDENCE · PUBLICATION STATUS

Benchmark Evidence & Publication Status

Every result on this site comes from a public benchmark dataset that I ran myself, with the raw logs published. Running a public benchmark is not the same as an outside party reproducing it or a leaderboard accepting it, so each result is labeled with exactly how far it has gone.

STATUS · SELF-RUN ON PUBLIC BENCHMARKS

Self-Run Evaluations (Published Logs)

Most results. Public datasets, run in my lab, raw logs published: Snap LoCoMo 90.26% accuracy / 95.77% evidence recall (1,540 questions); DolphinBench 90.67% with Grounded v0.3 (544/600; 90.50% on the Riley slice); AgentDojo 0/1,046 successful prompt-injection attacks; Aider Polyglot 51.56%; DABstep 9/10 tasks (small sample).

STATUS · SUBMITTED, AWAITING ACCEPTANCE

Official Submissions Queued

DolphinBench 91.17% (547/600, Gemini 4 Argon Low, UUID c047b063) and 54.17% (325/600, stock Gemma 4 31B, UUID 288671ad) pass the official validator and are uploaded to dolphinbench.ai, but are not yet on the leaderboard. Until accepted, read them as self-run results.

STATUS · UPSTREAM PR, CI CHECKS PASSED

RouterArena PR #169 (Open)

0.7263 across 8,400/8,400 live queries (74.44% accuracy at $0.38/1K). The project's own github-actions CI re-checked the submitted receipts; the pull request is open, not yet merged.

STATUS · THIRD-PARTY REPRODUCTION

None Yet — Invitation Open

No outside party has re-run these results yet. Scripts, frozen read-only memory stores, and 49 raw log sets (64 files) are public on Hugging Face so anyone can check them; reproduction attempts are welcome as GitHub issues.

Read Return on Memory Paper → arXiv Preprint PDF → Cross-Stack Benchmark Report → 🤗 Raw Audit Logs (49) →

ENGINEERING PHILOSOPHY

Core Architectural Invariants

The non-negotiable systems rules governing every layer in the KruschDev ecosystem.

01 / INVARIANTS OVER PROMPTS

Deterministic State Managers

Never trust language models to police their own file writes or follow conversational rules. Enforce constraints in PostgreSQL write-ahead state tables, AST dependency parsers, pre-commit SHA-256 drift guards, and POSIX atomic renameSync/fsync apply journals.

02 / ZERO ROUTING TAX

Multi-Tier Routing Cascades

Don't burn a 500ms LLM call just to choose an LLM. Intercept structured syntax in <15µs (<25µs ceiling) via an in-process pure-CPU Stage-0 syntactic/lexical gate prior to model inference for $0.00, escalate to sub-50ms neural centroids, and query frontier models only when necessary.

03 / LOCAL-FIRST SOVEREIGNTY

Offline-Capable Hardware Control

Run compute, vector indexes, and episodic memory on self-hosted bare-metal clusters. Offline-capable configurations keep privileged files and organizational memory within the self-hosted environment; cloud escalation, when enabled, sends the relevant prompts to the configured provider.

SYSTEMS RESEARCH & WHITEPAPERS

Technical Publications by Architectural Layer (26)

Reproducible architectural deep dives, empirical ablation benchmarks, and systems specifications.

Open Full Publications Catalog →

Agent Memory MCP Servers PostgreSQL & SQLite GPU & Cost Routing 2PC & Security Benchmarks & QLoRA Legal & Contract RAG Lego Code Bricks

TRACK I · LAYER 01

The 2026 Sovereign Tech Stack, Cross-Stack Benchmarks, Closed-Loop Audit & Operating Planes

End-to-end stack architecture, 15/15 production agentic systems matrix, 335,000+-trace cross-stack benchmark comparison across 14 external suites (95/95 SHA-256 clean-room gates), 5-GPU + 96GB G4 burst compute, 3-Tier MCP code audits, Wave-4/6 QLoRA+DPO self-distillation, and <15µs (<25µs ceiling) in-process pure-CPU Stage-0 syntactic/lexical gates prior to model inference.

Flagship Stack Blueprint krusch-stack v1.1 (Grounded + 2PC) @krusch/toolkit v1.8.1 + 8 MCPs 8K Arctic + QLoRA Distillation

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 + 8K snowflake-arctic-embed2 + 96GB Blackwell G4 burst, 8 MCP servers evaluated across 14 external benchmark suites (90.26% Snap LoCoMo [95.77% recall @ $0.00 ingest]; 91.17% DolphinBench uploaded submission UUID c047b063 queued awaiting leaderboard acceptance, plus self-run 600-task evaluations with published audit logs at 90.67% + Grounded v0.3 [90.50% on Riley] & 57.33% Wave-6 krush420/gemma4-31b-sre-lora @ $0.00 across 28 runs / 16,800 traces; 90.0% DABstep @ $0.81 [2.54x faster]; 2,000/2,000 BEAM; 0.7263 CI-verified RouterArena PR #169, ACL 2026 LLMRouterBench & Martian RouterBench; 47,998-Q RepoBench-R; 51.56% Aider Polyglot; 6,889-Q LegalBench-RAG), 39-brick @krusch/toolkit v1.8.1 (141/141 Node, 16 Slop-Breaker detectors, 104/104 compliance), krusch-stack v1.1 --defer-tools (-68.5% schema bytes) + Grounded v0.3 & 2PC Harnesses, and 4/4 Wave-4/6 31B/120B/30B/8B QLoRA+DPO adapters across 18,131 SFT+DPO rows.

Read 2026 Tech Stack Blueprint →

15/15 Production-Grade Patterns (Lab) 120+ Async Tasks · Typed Swarms 100 Golden DAGs · 72h Slack HITL $0.50 Kill-Switch · 5% Shadow Diff

The 15 Production Agentic Systems: Reference Architecture, State-Machine Invariants & Benchmark Proofs

Three architectural teardowns mapping all 15 production agentic engineering pillars across krusch-stack, krusch-agentic-proxy, and krusch-coding-harness: asyncio.Semaphore(128) orchestrators + circuit breakers, strict 3-bucket token budgeting, Pydantic v2 error-trace retry routers, frozen typed swarms, 72h HMAC-SHA256 Slack HITL leases, 100-trajectory Golden DAG CI gates, 0.00% ASR inter-agent sanitization (1,046-episode AgentDojo security suite), bwrap --unshare-net sandboxes, $0.50 cost kill-switches, REST-to-browser fallback, and 5% non-blocking shadow diffing.

Read 15-System Architecture Teardown →

Cross-Stack Benchmark Report 335,000+ Traces · 49 HF Logs (64 Files) 14 External Suites · 0.00% ASR (1,046 AgentDojo) Honest Gaps & 95/95 SHA-256 Gates

How an Open-Weights Sovereign Stack Stacks Up Across 335,000+ Benchmark Queries (Including Where Cloud Still Wins)

Empirical cross-stack comparison of krusch-stack against open-source wrapper stacks and commercial cloud stacks across 14 external suites (95/95 SHA-256 clean-room gates): DolphinBench (91.17% [547/600 @ $24.54] uploaded dolphinbench.ai submission UUID c047b063 queued awaiting leaderboard acceptance; plus self-run 600-task evaluations with published audit logs across 28 runs / 16,800 traces at 90.67% Argon Low + Grounded v0.3 [90.50% on Riley], 81.50% Luna + Grounded @ $1.35 [71.1x cheaper than Mem0], 57.33% Wave-6 krush420/gemma4-31b-sre-lora @ $0.00 [54.17% queued stock UUID 288671ad], and 98.33% Global Oracle@28), ACL 2024 Snap LoCoMo (90.26% [1,390/1,540], 95.77% dia_id recall [181.8ms] @ $0.00 zero-LLM ingest), Adyen DABstep (90.0% @ $0.81, -74.5% cost, 2.54x faster; 40.0% Gemma 4 31B @ $0.00), RouterArena (0.7263 CI-verified upstream submission PR #169 across 8,400/8,400 live receipts), ACL 2026 LLMRouterBench (0.4269 Pareto), Martian RouterBench (72,980 rows), ETH SpyLab AgentDojo v1.2.2 (19.28% → 0.00% ASR across 1,046 episodes), ACL 2025 CoIR (56.40% NDCG@10 across 162,216 Qs), BIRD-SQL Mini-Dev (26.00% → 40.20% EX), BFCL v3 Live (66.28% Micro, -80.67% schema tokens), ICLR 2026 BEAM, RepoBench-R, LegalBench-RAG, and Aider Polyglot (19.56% → 51.56%)—with explicit reader-ceiling and methodology caveats.

Read Cross-Stack Benchmark Report →

Autonomous SRE & Audit 3-Tier MCP Hydration Cross-Family Referees 18,131 SFT+DPO + 4/4 QLoRA (31B/120B/30B/8B)

🧠 The Closed-Loop Audit & Distillation Pipeline: 3-Tier MCP Context Hydration, Cross-Family Referees & Dual-Track QLoRA

How Jean SRE swept 88 repositories (Oct 2026 snapshot; 104 today) 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 4/4 @krush420 open-weights QLoRA+DPO adapters (Wave-6 Gemma 4 31B top open-weights self-run result 57.33% + Grounded @ $0.00, 120B Teacher [native Blackwell MXFP4], 30B Student, and 8B Edge) on 18,131 test-verified SFT + DPO trajectories.

Read Audit & QLoRA Pipeline Paper →

0.7263 CI-Verified RouterArena (PR #169) LLMRouterBench & RouterBench · <15µs CPU Gate -83.95% Cost · -48% TTFT

Multi-Tier Cascade Routing: Slashing Enterprise Inference Budgets by 60–80%

Systems architecture deep dive into krusch-cascade-router (0.7263 CI-verified upstream submission on RouteWorks RouterArena [PR #169, github-actions[bot] verified on 8,400/8,400 live receipts; 74.44% @ $0.3802/1K, 91.43% rob.], self-run benchmark evaluations on ACL 2026 LLMRouterBench [Pareto 0.4269 at -83.95% cost] and Martian RouterBench [72,980 rows at -72.63% cost], and -48.0% TTFT live SSE cascade) plus krusch-pre-router (<15µs typical / <25µs ceiling in-process pure-CPU Stage-0 syntactic/lexical gate prior to model inference, $0.00 tax).

Read Cascade Routing Whitepaper →

Flagship Architecture PostgreSQL State Plane

Postgres as the State Plane: Why Side Effects Require a Transaction Manager

Why autonomous agents require raw SQL and a write-ahead state manager—not ORMs or prompts: 0 JS ORMs across 48 repos, 252ms → 15.25ms HNSW+GIN CTEs in krusch-git, 10M-token memory, and 2.64x Aider Polyglot 2PC self-healing in krusch-coding-harness.

Read State Plane Architecture →

Hybrid Architecture PostgreSQL + pgGraph

🚀 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 →

TRACK II · LAYER 02

Agent Working Memory, Closed-System BEAM Benchmarks, Git DAG / AST Graphs & OS Substrates

The 5-verb MCP discipline, 90.26% ACL 2024 Snap LoCoMo (95.77% recall @ $0.00 ingest), DolphinBench Return on Memory (91.17% @ $24.54 uploaded submission UUID c047b063 queued awaiting leaderboard acceptance; plus self-run 600-task evaluations with published audit logs at 90.67% + Grounded v0.3 [90.50% on Riley], 81.50% Luna @ $1.35 [71x cheaper], 57.33% Gemma 4 31B Wave-6 + Grounded @ $0.00, & 98.33% Oracle@28 across 28 runs / 16,800 traces), 2,000/2,000 ICLR 2026 BEAM evaluation (100K–10M), relational AST symbol indexing, multi-node SSH fleet page trees, and swappable Postgres/SQLite drives.

Uploaded Submission Queued on dolphinbench.ai (91.17%) 90.67% Grounded v0.3 Repro (90.50% Riley) 28-Run Audit Logs (98.33% Oracle@28) · 90.26% LoCoMo

Return on Memory: Why Test-Time Reasoning Unlocks Zero-Distillation Agentic Retrieval on DolphinBench (91.17%)

Holding 13,539 episodic sessions byte-for-byte constant inside frozen 0o444 SQLite checkpoints ($0.00 Zero-LLM Raw-RAG + 4-Way RRF), my compiled 19-run (11,400-trace) arXiv preprint lifts accuracy from 18.33% (8B) to 54.17% (325/600, Stock Gemma 4 31B @ $0.00, uploaded submission UUID 288671ad queued on dolphinbench.ai), 81.33% (488/600 @ $1.35, 71.1x cheaper than Mem0) on model-matched GPT 5.6 Luna, and 91.17% (547/600 @ $24.54, uploaded submission UUID c047b063 queued on dolphinbench.ai awaiting leaderboard acceptance; exceeds current 70.67% published entry) with Gemini 4 Argon (Low)—subsequently expanded across 28 self-run 600-task evaluations with published audit logs to 98.33% Global Oracle@28, 90.67% (544/600) Argon Low + Grounded v0.3 (90.50% on Riley), 81.50% Luna + Grounded, 57.33% (344/600) Wave-6 krush420/gemma4-31b-sre-lora + Grounded @ $0.00, and 90.26% (1,390/1,540) ACL 2024 Snap LoCoMo (95.77% recall @ $0.00 ingest).

Read Return on Memory Paper →

DolphinBench 600 Repros (16,800 Traces) 57.33% Gemma 4 Wave-6 + Grounded @ $0 4/4 LoRA Lifts · -95.2% 2PC Dup Calls

What 5,535 DolphinBench Runs Taught Me About Local AI Memory

Controlled multi-family study across 28 self-run 600-task DolphinBench evaluations with published audit logs (16,800 traces, 98.33% Global Oracle@28) + 15 counterfactuals (13,539 sessions / 1.50M tokens, 0o444 frozen SQLite WAL): Wave-6 QLoRA+DPO krush420/gemma4-31b-sre-lora + Grounded reaches 57.33% (344/600, $0.00; +3.17 pp over 54.17% queued stock UUID 288671ad & +0.67 pp over 56.67% [340/600] Stock + Grounded, outscoring matched Qwen2.5-Coder-32B by +22.00 pp); 4/4 @krush420 open-weights adapters lift local Qwen3-Coder-30B-A3B to 43.00% + Grounded (42.67% Std., 61.17% Oracle@5), 120B to 39.50%, and 8B Q4_0 15.7x (18.33%); and my krusch-stack 2PC Action Harness cuts duplicate MCP calls -95.2% (42 → 2) across all 600 local 30B tasks.

Read Local AI Memory Study →

ICLR 2026 BEAM 100K–10M (2,000/2,000) v2.0.0 Multi-Scale Retrieval Beats past.dev CR (4/4) & 10M MSR

🔬 Benchmarking Agent Memory Without Cheating: Closed-System ICLR 2026 BEAM (100K–10M)

Evaluating krusch-context-mcp across all 100 conversations (~178.34M tokens) and 2,000/2,000 official BEAM probes on SQLite inside one 96GB Blackwell box: 92.58% 100K & 93.00% 10M IE recall, zero E2E drop to 1M, and beating cloud past.dev on CR (4/4) & 10M MSR.

Read Closed-System BEAM 2,000/2,000 Paper →

v0.3.1 · 8-Node Fleet KruschNexus Library Mode SHA-256 Page Memory

🗂️ 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.

Read krusch-fs-mcp Deep Dive →

v1.2.3 · RepoBench-R (47,998 Qs) Git DAG + Java/Py AST Beats CodeBERT & UniXcoder

🌳 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, multi-language AST lexing & live import-activity analysis, 15.25ms HNSW/GIN search, and 19.12% Macro Acc@1 (68.58% Acc@5) across 47,998 RepoBench-R queries.

Read krusch-git Architecture →

82★ Flagship MCP · v2.0.0 2,000/2,000 BEAM (100K–10M)

🧠 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 v2.0.0 (governed episodic memory, two-level episode rollups, 2-hop bridges, closed-system ICLR 2026 BEAM n = 2,000/2,000 evaluation across 100K–10M on 8K snowflake-arctic-embed2) and decoupling codebase RAG into krusch-git.

Read 5-Verb Memory Deep Dive →

Developer Substrate KruschContext + KruschGit Swappable Drives

💾 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.

Read Swappable Substrate Paper →

Enterprise MCP PostgreSQL 16 + pgvector

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 →

Code-Agent Architecture 12k Symbol Benchmark

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 →

TRACK III · LAYER 03

Transactional Coding Harnesses & Sovereign Daily Execution

Pre-commit diff staging, container sandbox verification, PostgreSQL write-ahead apply journals paired with POSIX atomic renameSync/fsync replacement, and local-first voice-driven agentic control.

39 Bricks (v1.8.1) · 7 Blueprints INV-LEGO-01..34 · 104/104 Repos 16-Rule Slop-Breaker Guard 25% → 100% QLoRA + DPO

Why Coding Agents Need Certified Lego Bricks, Not Prompted Boilerplate: Inside a 35-Brick, Self-Evolving Code Substrate

How I eliminated LLM-regenerated HTTP 413 TCP ECONNRESET races, DNS-rebinding SSRF, SQLite lock quarantine, and YAML alias bombs across 100 repositories (3,150+ files, expanded in @krusch/toolkit v1.8.1 & krusch_toolkit v1.6 to 39 dual-runtime bricks + 16 Slop-Breaker detectors across 104/104 repos): 7 zero-LLM blueprints, a comment/string-masked MCP pre-commit guard, an autonomous Rule-of-3 anti-bloat scout (8/8 clusters promoted), and 2-stage QLoRA + DPO calibration lifting zero-tool brick accuracy from 25.0% → 100.0%.

Read 35-Brick Lego Substrate Paper →

51.56% Aider Polyglot (2.64x) Bubblewrap Sandbox Write-Ahead Journal + POSIX Swap

🛡️ The Krusch Coding Harness: Why Autonomous Code Agents Require a Transaction Manager, Not a Prompt

Why unconstrained file writing breaks coding agents. Pre-commit SHA-256 diff staging, Bubblewrap isolation, verify-on-stop outer loops, and PostgreSQL write-ahead apply journals paired with POSIX atomic renameSync/fsync replacement (<32ms local journal+swap overhead)—lifting open-weights gpt-oss:120b from 19.56% → 51.56% (72 tasks self-healed) across 225/225 Aider Polyglot exercises.

Read Coding Harness Deep Dive →

Flagship Open Source · v1.2 Voice-First Whisper ASR 16-Tool <holodata> Proxy

🛡️ 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.

Read Companion Architecture & Playbook →

Open Source Release 12-Tool MCP Server 1,024-Dim Drive RAG

☁️ 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.

Read G-Krusch Architecture →

TRACK IV · LAYER 04

Offline-Capable Document Ingestion, Vector Geometry & Precedence Graphs

Layout-true coordinate spines, statutory preemption DAGs, confirmed-edge contract graphs, and versioned rulebooks.

Architectural Whitepaper GC Benchmark (n=180) 0.0% Wrong-Law Blend

📦 Authority Packs: Versioned 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 →

v0.8.0 · 200 Tests Confirmed Precedence DAG The Join: Contract vs Statute

💼 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 →

v0.7.0 · 156 Tests 0.00% FSR · Labeled Golden Sets Preemption DAG & as_of_date

⚖️ Why I Built KruschLaw: Sovereign Legal Intelligence, Two-Pass Grounding & Statutory Precedence

Why generalist RAG fails in statutory law. 0.00% False Support Rate on labeled statutory & contract golden evaluation sets (KruschLaw / KruschBiz; a test result, not a guarantee), versioned statutory precedence graphs (resolve_controlling_law with as_of_date), tenant defense deadlines, and cryptographic purge.

Read KruschLaw Architecture →

v0.2.6 · 206 Tests LegalBench-RAG (6,889 Qs) 26.74% Macro F1 · 100% Citation

⚖️ Citations Die in Local RAG: Why I Built KruschNexus and What It's For

Why arbitrary token slicing destroys document citations. 7-parser-family held-out evaluation (100% citation accuracy), contextual section-path embeddings + local mxbai-rerank-large-v2 cross-encoder achieving 26.74% Macro F1 (k=1), 25.81% F1 / 44.72% Recall (k=2), and 47.71% Recall (k=6) across 6,889 LegalBench-RAG queries (beating OpenAI text-embedding-3-large + Cohere Rerank Recall@64 on MAUD).

Read KruschNexus Deep Dive →

Sovereign Fleet (587 Tests) Citation Spine Closed-Loop Grounding

⚖️ 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 →

Vector Space Geometry Parser Contracts Failure Mode Analysis

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 →