# Krusch Dev — Kevin Ruschman

> Kevin Ruschman (@kruschdev, ORCID 0009-0007-7437-2383) — **AI Infrastructure Engineer | Agent Systems | Reliability & Verification** — *"building the reliability infrastructure that makes autonomous AI systems safe, persistent, and useful"* inside his independent bare-metal R&D lab (`@kruschdev`). Independent engineering research and open-source development. Projects and reference architectures are developed and tested in my own lab unless otherwise indicated. Leading with three test-verified open-source systems: krusch-context-mcp (82★, 7 forks, 86 monthly npm downloads, 144/144 tests), @krusch/toolkit v1.8.1 & krusch_toolkit v1.6.0 (39 dual-runtime bricks, 16 <1ms static/AST Slop-Breaker detectors, 141/141 Node & 201/201 pytest tests), and krusch-coding-harness + krusch-grounded-harness (116/116 + 7/7 tests including a real SIGKILL-mid-apply crash test (crash-smoke.test.js)).

Target Engineering Roles: Seeking engineering roles on teams building agent infrastructure, persistent memory, model orchestration, sandboxed code execution environments, or AI reliability and evaluation — Los Angeles, CA · Hybrid · Remote.

Evaluation scope: Evaluated across 335,000+ traces and 14 external benchmark suites, with published SHA-256 audit logs and reproducible evaluation artifacts.

Lab provenance: "Independent engineering research and open-source development. Projects and reference architectures are developed and tested in my own lab unless otherwise indicated."

Engineering background: From 2014 to 2023, Kevin Ruschman built his operational foundation through hands-on electrical and mechanical work in Southern Vermont, supervising a mobile field-diagnostics crew for the Wisconsin Bicycle Federation, launching and operating a physical business to first-year profitability in Aspen, CO, and Eagle Scout leadership. Diagnosing physical systems where silent faults carry immediate real-world consequences directly shaped his reliability-first, failure-mode-driven AI systems engineering philosophy: crash-injected state transitions, explicit architectural limits, and deterministic verification gates.

Machine-readable full digest with executive TL;DRs and section outlines: [llms-full.txt](https://krusch.dev/llms-full.txt).

## Core Open-Source Repositories

- [krusch-context-mcp v2.0.0](https://github.com/kruschdev/krusch-context-mcp): 5-verb governed working-memory MCP server (82★, 7 forks, 86 monthly npm downloads, 144/144 tests) with SHA-256 provenance drift checks (INV-12) and zero-LLM SQLite WAL / PostgreSQL hybrid retrieval. Limitations: 1.67% (10/600) zero-LLM Raw-RAG synthesis miss rate on queries requiring pre-consolidated abstractive cross-session synthesis, and single-host SQLite WAL write scope unless paired with PostgreSQL.
- [@krusch/toolkit v1.8.1 & krusch_toolkit v1.6.0](https://github.com/kruschdev/toolkit): Certified dual-runtime Lego substrates comprising 39 JS/TS and Python bricks (64 .d.ts subpaths, 7 zero-LLM blueprints, 141/141 Node tests & 201/201 pytest tests, 104/104 workspace compliance) plus 16 <1ms static/AST Slop-Breaker detectors. Limitations: Static/AST 16-rule detector scope enforces structural infrastructure invariants rather than arbitrary domain business logic.
- [krusch-coding-harness & krusch-grounded-harness v0.3.0](https://github.com/kruschdev/krusch-coding-harness): Two-phase commit (2PC) Bubblewrap execution control plane and Turn-0 Grounded Harness (116/116 + 7/7 tests including a real SIGKILL-mid-apply crash test (crash-smoke.test.js), <32ms PostgreSQL write-ahead apply journal + POSIX atomic renameSync/fsync + pre-commit SHA-256 drift check, -95.2% duplicate MCP calls). Limitations: Cross-filesystem POSIX copy+fsync fallback and a narrow external-editor race window between the pre-commit SHA-256 drift check and renameSync when run on a shared working tree without container or git-worktree isolation.

## Core Pages

- [Home — AI Infrastructure, Agent Systems & Reliability R&D Portfolio](https://krusch.dev/): Independent bare-metal R&D lab portfolio by Kevin Ruschman (@kruschdev — AI Infrastructure Engineer | Agent Systems | Reliability & Verification).
- [Systems Architecture Publications (26 Whitepapers)](https://krusch.dev/articles/): Searchable catalog of all 26 empirical monographs with Technical and Plain-English reading modes.
- [Enterprise Offline-Capable Reference Architecture Blueprint](https://krusch.dev/sovereign/): Reference hardware topology, network-isolation controls, zero-egress security, and deployment blueprint for offline-capable enterprise AI infrastructure.
- [Technical Resume — Kevin Ruschman](https://krusch.dev/resume): AI Infrastructure Engineer | Agent Systems | Reliability & Verification — open-source systems record, failure-mode verification suites, operational background, and target engineering roles.
- [Engineering Roles & Direct Inquiry](https://krusch.dev/contact): Direct contact channel — seeking engineering roles on teams building agent infrastructure, persistent memory, model orchestration, sandboxed code execution environments, or AI reliability and evaluation (Los Angeles, CA · Hybrid · Remote).
- [Return on Memory Preprint (PDF)](https://krusch.dev/papers/return-on-memory-dolphinbench.pdf): 16-page peer-style preprint on zero-distillation SQLite Raw-RAG working memory evaluated across 28 DolphinBench runs (16,800 traces) and ACL 2024 Snap LoCoMo.
- [Full Whitepaper Digest (llms-full.txt)](https://krusch.dev/llms-full.txt): Complete abstracts, Plain-English TL;DRs, section outlines, and topic metadata for all 26 whitepapers.
- [Publications RSS 2.0 Feed](https://krusch.dev/feed.xml): Syndicated XML feed of all 26 systems architecture publications.

## 3-Category Benchmark Verification Taxonomy

Evaluated across 335,000+ traces and 14 external benchmark suites, with published SHA-256 audit logs and reproducible evaluation artifacts ([49 SHA-256-pinned raw JSON audit logs across 64 files and 95/95 clean-room gates](https://huggingface.co/datasets/krush420/sovereign-g4-benchmarks)):

1. *CI-Verified Upstream Submission*: `RouteWorks/RouterArena PR #169` (`0.7263` across `8,400/8,400` live receipts — `74.44%` accuracy @ `$0.3802/1K` queries, `91.43%` robustness — verified by `github-actions[bot]`).
2. *Uploaded Submissions Awaiting Leaderboard Acceptance*: `8` `submission.validate`-passing `DolphinBench` `.zip` archives uploaded to `dolphinbench.ai` (`status: "queued"` awaiting maintainer queue processing, including `91.17%` [`547/600`] `Argon Low` `UUID c047b063` @ `$24.54` and `54.17%` [`325/600`] Stock `Gemma 4 31B` `UUID 288671ad` @ `$0.00` — exceeding current `70.67%` published leaderboard entries in independent `600/600` runs prior to official acceptance).
3. *Self-Run Benchmark Evaluations (Published Audit Logs)*: `20` clean-room `DolphinBench` controls (`90.67%` [`544/600`] `Argon Low + Grounded v0.3` [`90.50%` on `Riley`, `181/200`] @ `$30.54`, `81.50%` [`489/600`] model-matched `GPT 5.6 Luna + Grounded` @ `$1.35` [`30.03s = 1.57x` faster; `81.33%` Base; `71.1x` cheaper than Mem0; `91.83%` Luna `Oracle@5`], `57.33%` [`344/600`] Wave-6 `Gemma 4 31B` `krush420/gemma4-31b-sre-lora` @ `$0.00` top open-weights self-run result [`56.67%` Stock + Grounded; `43.00%` local 30B Wave-4], `98.33%` [`590/600`] `Oracle@28`, `94.67%` [`568/600`] `Argon Low Oracle@2`, `96.83%` [`581/600`] `Argon Oracle@4`, `83.17%` [`499/600`] `$0.00 Oracle@17`), ACL 2024 `Snap LoCoMo` (`1,540/1,540` QA probes: `90.26%` `argon_matched` accuracy / `95.77%` `dia_id` recall @ `$0.00` zero-LLM ingest / `89.68%` `argon_tight` @ `4,465` mean tokens / `92.66%` `Oracle@2`), ICLR 2026 `BEAM` (`2,000/2,000` probes across `100K–10M` tokens), ETH SpyLab `AgentDojo` (`0/1,046` ASR, `0.00%` Attack Success Rate), `DABstep` (`90.0%` @ `$0.81` [`-74.5%` cost, `2.54x` faster] on Gemini 4 Argon; `40.0%` Gemma 4 31B @ `$0.00`), ACL 2026 `LLMRouterBench` (`0.4269` Pareto, `-83.95%` cost), Martian `RouterBench` (`72,980` rows ID/OOD AIQ), `Aider Polyglot` (`51.56%`, `2.64x` lift from `19.56%`), `RepoBench-R` (`47,998` queries, `15.25ms` hybrid RRF), and `LegalBench-RAG` (`6,889` queries, `100%` Poppler TSV citation accuracy).

## Supporting Open-Source Systems & Verification Hubs

- [Sovereign G4 Benchmark Verification Hub](https://huggingface.co/datasets/krush420/sovereign-g4-benchmarks): 49 SHA-256-pinned raw JSON audit logs across 64 files and 95/95 clean-room gates spanning 335,000+ traces and 14 external benchmark suites.
- [krusch-stack v1.1.0](https://github.com/kruschdev/krusch-stack): Unified 1-command installer bundling 39 annotated MCP tools across 7 pillars (-68.5% static / -80.67% BFCL v3 schema tokens), Turn-0 Grounded Harness v0.3.0 (90.0% DABstep @ $0.81 [-74.5% cost, 2.54x faster] on Gemini 4 Argon; 40.0% Gemma 4 31B @ $0.00 [2x lift]), Aider Polyglot 2.64x lift (19.56% to 51.56%), and 0/1,046 ASR (0.00%) across AgentDojo security episodes.
- [krusch-cascade-router](https://github.com/kruschdev/krusch-cascade-router): <15µs pure-CPU Stage-0 syntactic dispatch gate prior to LLM inference, 8K Arctic centroid router, and live SSE logprob abort (CI-verified RouteWorks/RouterArena PR #169 at 0.7263 across 8,400/8,400 live receipts verified by github-actions[bot]; self-run ACL 2026 LLMRouterBench 0.4269 Pareto & Martian RouterBench ID/OOD AIQ).
- [krusch-git](https://github.com/kruschdev/krusch-git): Git DAG indexer, multi-language AST call-graph engine, and 15.25ms PostgreSQL 16 HNSW/GIN hybrid code search evaluated on 47,998 RepoBench-R queries.
- [krusch-fs-mcp](https://github.com/kruschdev/krusch-fs-mcp): Multi-node OS filesystem page-tree indexer with SHA-256 drift verification and secret-redacted configuration search.
- [Jean SRE](https://github.com/kruschdev/Jean-SRE-by-kruschdev): Autonomous 24/7 code audit daemon sweeping 104 repositories with Cross-Family Referee Consensus and 18,131 Zero-Leak SFT+DPO distillation trajectories.
- [krusch-law & krusch-nexus](https://github.com/kruschdev/krusch-law): Offline-capable Poppler TSV citation spines (100% citation accuracy on 6,889 LegalBench-RAG queries) and statutory/contract precedence graphs achieving 0.00% False Support Rate (FSR) bounded to labeled statutory/contract golden sets.
- [Sovereign Router Arena](https://huggingface.co/spaces/krush420/sovereign-router-arena): Interactive Pareto cost-versus-accuracy telemetry explorer across routing and memory benchmarks.
- [Sovereign Code Audit SFT+DPO Dataset](https://huggingface.co/datasets/krush420/sovereign-code-audit-sft): 18,131 test-verified, zero-leak SFT and DPO preference rows powering all 4/4 @krush420 open-weights QLoRA+DPO adapters (Wave-6 gemma4-31b-sre-lora 57.33% top open-weights self-run result, qwen3-coder-30b-sre-lora 43.00% top local Qwen/MoE reproduction, gpt-oss-120b-sre-lora 39.50%, & llama3-hermes3-8b-sre-lora 18.33% [15.7x lift]).

## Track 01 — Sovereign Tech Stack, Cross-Stack Benchmarks, Closed-Loop Audit & Routing

- [The 2026 Sovereign AI Tech Stack](https://krusch.dev/articles/the-sovereign-ai-tech-stack): End-to-end systems architecture blueprint of the 2026 KruschDev tech stack: 5 bare-metal GPUs + 96GB Blackwell G4 burst, 8K snowflake-arctic-embed2, krusch-stack v1.1.0 & krusch-grounded-harness v0.3 (39 MCP tools, BM25 deferred loading, Turn-0 Grounded Harness & INV-STACK-10 2PC action harness), Evaluated across 335,000+ traces and 14 external benchmark suites (with published SHA-256 audit logs, 49 HF audit logs across 64 files, 95/95 SHA-256 clean-room gates: top Martian RouterBench, 0.7263 RouteWorks/RouterArena PR #169 (#13/34, github-actions[bot] CI-verified upstream PR), top LLMRouterBench self-run evaluation, 90.0% Adyen DABstep @ $0.81 [-74.5% cost, 2.54x faster], 91.17% (547/600 @ $24.54, uploaded dolphinbench.ai submission UUID c047b063, queued awaiting leaderboard acceptance; exceeds current 70.67% published entry) & 90.67% (544/600 @ $30.54, 90.50% [181/200] highest Riley slice in self-run 28-run evaluation) on Argon Low + Grounded v0.3 [94.67% Oracle@2, 98.33% Global Oracle@28], 81.50% model-matched GPT 5.6 Luna + Grounded @ $1.35 [1.57x faster, 71.1x cheaper], 57.33% (344/600 @ $0.00, highest open-weights score in self-run 28-run evaluation; 54.17% [325/600] uploaded stock submission UUID 288671ad queued on dolphinbench.ai; 56.67% Stock + Grounded) on krush420/gemma4-31b-sre-lora + Grounded & 43.00% local 30B Wave-4 + Grounded [42.67% Std.] @ $0.00 across 28 runs / 16,800 traces, 90.26% Snap LoCoMo [1,390/1,540, 95.77% dia_id recall, 89.68% tight @ 6.73x compression, 92.66% Oracle@2 @ $0.00 ingest], 0.00% ASR AgentDojo [1,046 episodes], 56.40% ACL 2025 CoIR (top NDCG@10 vs. published baselines, self-run), 40.20% BIRD-SQL, 66.28% BFCL Live, 51.56% Polyglot, RepoBench-R, LegalBench-RAG & ICLR 2026 BEAM), @krusch/toolkit v1.8.1 (39 Lego bricks, 16 Slop-Breakers, 104/104 compliance), and 4/4 open-weights 31B/120B/30B/8B QLoRA+DPO distillation.
- [The 15 Production Agentic Systems: Reference Architecture, State-Machine Invariants, and Benchmark Proofs Across a Sovereign Stack](https://krusch.dev/articles/fifteen-production-agent-systems): Complete engineering teardown of the 15 production agentic systems—mapping async 100+ task concurrency, strict 3-bucket context budgeting, Pydantic v2 tool routers, 2PC Verify-on-Stop loops (19.56% to 51.56% Aider Polyglot Pass@2), 72-hour HMAC Slack HITL gates, 0% AgentDojo prompt-injection ASR, $0.50 cost kill-switches, and 5% shadow trajectory comparators to open-source repositories.
- [How an Open-Weights Sovereign Stack Stacks Up Across 335,000+ Benchmark Queries](https://krusch.dev/articles/how-krusch-stack-stacks-up): Empirical cross-stack comparison of krusch-stack v1.1.0 — Evaluated across 335,000+ traces and 14 external benchmark suites (with published SHA-256 audit logs): Official DolphinBench (28 runs / 16,800 traces / 6 families: 91.17% [547/600 @ $24.54, uploaded dolphinbench.ai submission UUID c047b063, queued awaiting leaderboard acceptance; exceeds current 70.67% published entry] Argon Low, 90.67% [544/600 @ $30.54, 90.50% (181/200) highest Riley slice in self-run 28-run evaluation] Argon Low + Grounded v0.3 [93.73% invoked judge, 94.67% Oracle@2, 95.83% Oracle@3, 96.83% Argon Oracle@4], 81.50% model-matched GPT 5.6 Luna High + Grounded @ $1.35 [1.57x faster, 71.1x cheaper], 57.33% [344/600 @ $0.00, highest open-weights score in self-run 28-run evaluation; 54.17% (325/600) uploaded stock submission UUID 288671ad queued on dolphinbench.ai; 56.67% Stock + Grounded] krush420/gemma4-31b-sre-lora + Grounded & 43.00% local 30B Wave-4 + Grounded [42.67% Std.] @ $0.00, 98.33% Global Oracle@28 [590/600, <=1.67% misses], 83.17% $0.00 Oracle@17, 71.83% Gemma 4 Oracle@6, 8 validated .zips queued on dolphinbench.ai + 20 clean-room controls), Snap LoCoMo ACL 2024 (1,540/1,540 probes: 90.26% [1,390/1,540] & 95.77% dia_id recall matched [+19.86 pp > LivingBrain 70.4%], 89.68% [1,381/1,540] tight @ 6.73x compression, 92.66% Oracle@2 @ $0.00 ingest), Adyen DABstep (90.0% Argon @ $0.81 [-74.5% cost, 2.54x faster] & 2x [40.0% vs.
- [The Closed-Loop Audit & Distillation Pipeline: How I Hydrate Context via 3-Tier MCPs, Gate Fixes with Cross-Family Referees, and Fine-Tune Models on My Own Stack](https://krusch.dev/articles/how-i-use-jean-for-code-audits): How Jean SRE and the KruschDev audit pipeline combine 3-Tier MCP context hydration (krusch-context-mcp, krusch-git AST graphs, krusch-fs page trees), 11-checkpoint adversarial steel-manning, cross-family Referee convergence gates, and 120B/30B/8B Wave-4 QLoRA + DPO fine-tuning across 18,131 test-verified SFT + DPO records.
- [Multi-Tier Cascade Routing Architecture: Engineering Microsecond CPU Gating, Neural Centroids, and Speculative Hedging for High-Throughput Agent Swarms](https://krusch.dev/articles/multi-tier-cascade-routing): Systems architecture paper: Optimizing enterprise LLM inference budgets using hierarchical multi-tier cascade routing.
- [Postgres as the State Plane: Why Side Effects Require a Transaction Manager, Not a Prompt](https://krusch.dev/articles/postgres-as-operating-plane-for-ai): A language model is a probabilistic sampler; side effects require a transaction manager.

## Track 02 — Working Memory, Return on Memory, BEAM Benchmarks & AST/FS Graphs

- [Return on Memory: 91.17% (#1 Overall), 81.33% ($1.35 GPT 5.6 Luna) & 54.17% ($0.00 Open-Weights) Across 11,400 Official DolphinBench Traces](https://krusch.dev/articles/return-on-memory-dolphinbench): Preprint (19-run snapshot) on zero-distillation SQLite Raw-RAG working memory for agents on DolphinBench.
- [What 5,535 DolphinBench Runs Taught Me About Local AI Memory](https://krusch.dev/articles/what-dolphinbench-taught-me-about-local-ai): What 5,535 local ablation traces (9 runs) + 16,800 official gpt-5.6-sol traces (28 runs across 6 model families: 17 $0.00 open-weights + 11 frontier/model-matched) on DolphinBench taught me about zero-LLM Raw-RAG memory (+12.50 pp Alex, +10.50 pp Riley; 81.50% Grounded [1.57x faster] / 81.33% Base @ $1.35 on model-matched GPT 5.6 Luna, +10.83 pp & 71.1x cheaper than Mem0; 90.26% Snap LoCoMo QA & 95.77% recall @ $0.00 ingest), Wave-6 QLoRA + BF16 DPO + Grounded (krush420/gemma4-31b-sre-lora 57.33% [344/600 @ $0.00, highest open-weights score in self-run 28-run evaluation; 54.17% [325/600] uploaded stock submission UUID 288671ad queued on dolphinbench.ai], Gemma 4 Oracle@6 = 71.83%, $0 Oracle@17 = 83.17%), 2PC (-95.2% dup calls), and Gemini 4 Argon Low (91.17% [547/600 @ $24.54, uploaded dolphinbench.ai submission UUID c047b063, queued awaiting leaderboard acceptance; exceeds current 70.67% published entry], 90.67% [544/600 @ $30.54, 90.50% [181/200] highest Riley slice in self-run 28-run evaluation] on Grounded v0.3, Argon Low Oracle@2 = 94.67%, Oracle@28 = 98.33%).
- [Benchmarking Agent Memory Without Cheating: Closed-System ICLR 2026 BEAM (100K–10M)](https://krusch.dev/articles/iclr-2026-beam-closed-system-benchmark): Closed-system evaluation of krusch-context-mcp (v1.9.0 & v2.0.0) across all 100 conversations (~178.34M tokens) and 2,000/2,000 Official ICLR 2026 BEAM probes (100K–10M) on SQLite inside a 96GB RTX PRO 6000 Blackwell box: 92.58% 100K & 93.00% 10M IE recall, zero E2E drop to 1M (72.86%), and beating cloud past.dev on Contradiction Resolution (4/4 splits) & 10M Multi-Session Reasoning.
- [What Makes krusch-context-mcp Special](https://krusch.dev/articles/what-makes-krusch-context-mcp-special): Engineering deep dive into krusch-context-mcp (v2.0.0, 82★): the 5-verb discipline (~350 prompt tokens), closed write taxonomy, temporal lineage, zero-Docker Node 22 SQLite, Official Snap LoCoMo 1,540/1,540 evaluation (90.26% argon_matched & 95.77% dia_id recall @ $0.00 zero-LLM ingestion, 92.66% Oracle@2), Official DolphinBench 28-run / 16,800-trace evaluation (91.17%, 547/600 @ $24.54, uploaded dolphinbench.ai submission UUID c047b063, queued awaiting leaderboard acceptance, exceeding current 70.67% published entry; 90.67%, 544/600 @ $30.54, 90.50% [181/200] highest Riley slice in self-run 28-run evaluation; 57.33%, 344/600 @ $0.00 highest open-weights score & 54.17% queued stock UUID 288671ad; 98.33% Oracle@28), and 2,000/2,000 ICLR 2026 BEAM evaluation—evaluated across 335,000+ traces and 14 external benchmark suites (with published SHA-256 audit logs).
- [krusch-git: Git DAG Indexing, Relational AST Symbols & Hybrid Recency Search](https://krusch.dev/articles/krusch-git-architecture): A deep systems architecture analysis of krusch-git (v1.2.1): indexing Git DAG objects into PostgreSQL + pgvector, zero-dependency AST chunking, multi-hop symbol dependency graphs, exponential temporal decay (e^-0.01t), and hybrid Reciprocal Rank Fusion.
- [krusch-fs-mcp: OS Filesystem Page Memory, SHA-256 Drift Detection, and Multi-Node Fleet Indexing for AI Agents](https://krusch.dev/articles/krusch-fs-architecture): Systems architecture deep dive into krusch-fs-mcp (v0.3.0-alpha): transforming unstructured OS directories, PDFs, DOCX, systemd units, and multi-node SSH server fleets into a deterministic, page-indexed, SHA-256 drift-verified MCP memory substrate powered by KruschNexus Library Mode.
- [Architecting Code-Agent Retrieval & Memory: Beyond Naive Vector Search to Single-Store PostgreSQL 16 Hybrid Systems](https://krusch.dev/articles/code-agent-retrieval-memory-postgres): A practitioner's deep dive into code-agent retrieval architectures — single-store PostgreSQL 16 + pgvector HNSW, structural symbol lexing, Reciprocal Rank Fusion, dependency graph walks, token budget packing, and empirical retrieval evaluations across 12k symbols.
- [Sovereign Context & Safe Mutation Architecture for Coding Agents: Decoupling Tool Density, Stratified Decay, and Transactional State](https://krusch.dev/articles/enterprise-mcp-hub-architecture): Systems architecture reference paper: Decoupling Enterprise Access Gateways from the Sovereign Context & Working-Memory Plane (krusch-context-mcp) and Safe Execution Harness (krusch).

## Track 03 — Release-Gated Lego Substrates, 2PC Sandboxes, Swappable Storage & Personal AI

- [Why Coding Agents Need Certified Lego Bricks, Not Prompted Boilerplate: Inside a 35-Brick, Self-Evolving Code Substrate](https://krusch.dev/articles/lego-system-for-code): How I eliminated LLM-regenerated systems bugs across 100 repositories (3,150+ files) using 35 dual-runtime JS/TS & Python Lego bricks (@krusch/toolkit v1.7 & krusch_toolkit v1.6), 7 zero-LLM blueprints, a 10-rule pre-commit MCP boilerplate guard, a deterministic Rule-of-3 anti-bloat scout (8/8 clusters promoted), and 2-stage QLoRA + DPO calibration (25% to 100% brick adoption).
- [The Krusch Coding Harness: Why Autonomous Code Agents Require a Transaction Manager, Not a Prompt](https://krusch.dev/articles/krusch-coding-harness): A systems architecture deep dive into krusch-coding-harness (v0.1.0): why unconstrained file writing is a flawed paradigm for autonomous agents, pre-commit diff staging, Bubblewrap container sandboxes, storage-engine apply journals, row-locked catalog FSMs, and the architectural trade-offs of a relational state plane.
- [Zero-Friction Agent Substrates: Powering KruschContext & KruschGit with Swappable Local & Polygres Drives](https://krusch.dev/articles/zero-friction-sovereignty-polygres): Codespaces cannot see your local GPU — how AI coding agents eliminate amnesia with ACID decision logs (krusch-context) and navigate code with relational AST graphs (krusch-git)—running on local SQLite or Polygres Cloud without changing agent tools.
- [Local-First Core, Hybrid Cloud Elasticity: The Architecture, Failure Modes, and Trade-offs of Coding-Agent Memory](https://krusch.dev/articles/cloud-native-memory): A practitioner's analysis of coding-agent memory topologies: SQLite edge caching (sub-5ms reads), PostgreSQL durability, embedding parity pitfalls, two-stage HNSW decay indexing, and the realities of data sovereignty.
- [Introducing Krusch Companion: A Sovereign, Voice-First Personal AI Assistant & Dual-Axis Daily Execution Engine](https://krusch.dev/articles/introducing-krusch-companion): Complete guide to Krusch Companion (v1.2): Why you need a 100% local-first personal AI assistant, how the Dual-Axis Priority Board solves the Priority Paradox, voice-to-text capture, the 14-tool holodata agentic proxy, step-by-step setup, and a practical playbook for daily efficiency.
- [Introducing G-Krusch: A Sovereign Google Workspace Hub, Hybrid Drive RAG & MCP Bridge](https://krusch.dev/articles/introducing-g-krusch): Complete architectural deep dive into G-Krusch: a sovereign Google Workspace Hub and 12-tool MCP server with cloud-synced agent.md steering, 1,024-dim hybrid Drive RAG, 3-tier PDF extraction, and AES-256-GCM security hardening.

## Track 04 — Offline-Capable Document Ingestion, Statutory Precedence & Contract Intelligence

- [Citation Spine, Statutory Graph & Working Memory: Systems Architecture Note on Bounding Generative Error in Legal Workflows](https://krusch.dev/articles/the-sovereign-triad): A systems architecture note on bounding generative error in legal RAG: layout-true ingestion geometry, deterministic jurisdiction filtering, claim-level entailment, and episodic memory hygiene.
- [Citations Die in Local RAG: Why I Built KruschNexus and What It's For](https://krusch.dev/articles/why-i-built-krusch-nexus): Ingestion destroys locator fidelity; this is the spine I built to keep page and span coordinates intact.
- [Why I Built KruschLaw: Sovereign Legal Intelligence, Two-Pass Grounding & Statutory Precedence](https://krusch.dev/articles/why-i-built-kruschlaw): Local-first statutory intelligence: 0.00% False Support Rate assertion grounding, versioned statutory precedence DAG with temporal time-travel, tenant defense checklists, and cryptographic purge.
- [Why Semantic Similarity Isn't Governing Precedence: What Makes KruschBiz Different From Generic Business RAG](https://krusch.dev/articles/why-krusch-biz-differs-from-business-rag): Vector search fails on enterprise contracts because cosine distance has zero legal precedence.
- [Authority Packs: Controlled Rulebooks for Enterprise AI — Sovereign Domain Scoping vs. Vector Bleed](https://krusch.dev/articles/authority-packs): Why enterprise buyers don't buy retrieval — a systems architecture and commercial blueprint for Authority Packs: bounded, versioned rulebooks, span-grounded slots, and preemption graphs.
- [The Ingestion Imperative: Why Retrieval Quality Is Bounded Before the Model Reads a Single Word](https://krusch.dev/articles/the-ingestion-imperative): A systems architecture note on document engineering, vector embedding space geometry, measured failure modes of ingestion, and the failure modes of the structured antidote.