The archive, mapped

I put fi-fhir and edilint through Mills for the first time. It merged work I did not write, then exposed a test gate passing on the wrong tree and fixed it against itself.

A design pattern for supervised AI investigations: scoped read access, reviewed drafts, and failure tests before expanding permissions.

MCP shipped a breaking specification revision. I wrote the gap analysis, filed it as factory backlog, and Mills started rebuilding the SDK it runs on.

A fleet-wide maintenance day exposed seven ways CI can report success without useful work—and the merge-queue discipline and recurring checks built to catch them.

Four defect classes that healthcare interchange parsers can accept silently, with synthetic samples, real linter output, and the pre-send gate that catches them.

A twin-lane canary promoted prefix caching, FP8 KV cache, and a larger context pool while catching five regressions before they reached the primary workload.

How five simulated minds share one 24 GB Radeon, keep 200K-token life histories, reuse them through prefix caching, and compact old memories without erasing continuity.

A July 2026 platform snapshot: multimodal inference, Mills delivery, flight recording, and the operational gaps that remained after the demos worked.

I replaced FlexInfer’s unused gaming-mode stub with a declarative GamingSession resource that drains inference and turns a GPU node into a Moonlight host.

Needle-retrieval tests on a 35B model passed near 63,000 prompt tokens and failed at longer contexts, even when vLLM loaded without a memory error.

The May 2026 design for Loom Mills: turn roadmap intent into scoped work, verify each change, and keep costs, failures, and operator controls visible.

A short, adoptable AI usage policy for engineering teams: what to put on the page, what to leave off, and why the policy matters less than the habits it makes explicit.

A 90-day rollout for AI-assisted development: start with bounded habits, measure the work, and standardize only after the team has evidence.

Field notes from serving Gemma 4 E4B on Radeon: the stable TRITON path, an experimental TurboQuant long-context lane, and the GPTQ work still in progress.

How I use AI drafts to build engineering judgment through inspection, regression tests, code review, and repeatable release checks.

Treat the repository as a control system: versioned instructions, explicit workflows, fast hooks, durable context, and visible failure states.

How Loom generates and checks MCP configuration across nine client profiles from one canonical registry.

How Loom keeps MCP tooling predictable with one client entrypoint, daemon-owned process lifecycles, bounded output, and coarse-grained tools.

A February 2026 GPU allocation experiment: separating text workloads, testing shared-group priorities, and keeping client routes stable as models moved.

How I evolved a small AMD GPU cluster into a CRD-driven inference platform with an OpenAI-compatible boundary, evidence-based model promotion, and safe rollouts.

How fi-fhir separates feed-specific variance from parsing, semantic events, durable delivery, and workflow policy—and where the pre-1.0 platform still has work to do.

What actually broke when I deployed MLC-LLM across two RX 7900 XTX nodes, and the fixes that made it stable: quantization, KV cache sizing, and Kubernetes GPU hygiene.

How I define request, cold-start, queue, and model-quality objectives for an inference service without confusing causes with user outcomes.

Field notes from building and operating a small private GPU platform with Harvester, K3s, and a GitLab -> Flux delivery loop.

The contracts I use to operate mixed-vendor GPU capacity with Kubernetes and Flux, including cost, storage, scheduling, and rollback limits.

A cross-vendor incident workflow for separating GPU scheduling, driver, memory, model-loading, and request-path failures.

A reproducible way to join GPU capacity, utilization, request outcomes, and cost without pretending allocation equals useful work.

The evidence I collect before recommending changes to GPU cost, inference reliability, or deployment operations.

What the current FlexDeck code does to keep Canvas 2D and Three.js cluster views responsive, and how its performance harness avoids unsupported frame-rate claims.

A de-identified field pattern for containing patient-match risk when filter and mode parameters interact in undocumented ways.

An August 2026 tour of the Harvester, K3s, GitLab, Harbor, Flux, and mixed-GPU platform behind the systems I publish here.

What still works, what changed, and which guardrails matter when you run AMD Radeon GPUs for always-on inference.

A source-backed guide to agent reliability: explicit state, bounded tools, verification gates, and visible failure.

How FlexDeck combines Kubernetes, Flux, CI, observability, and model state without hiding freshness, access boundaries, or the limits of a homelab control surface.