The archive, mapped

One day of fleet-wide portfolio maintenance turned into a taxonomy of seven ways a system reports success without doing any work, a merge-queue discipline built on the difference between arming and firing, and a permanent maintenance loop to replace the one-shot cleanup. With the numbers, the mistakes, and the night the factory diagnosed itself.

The sequel to Five Voices: in one day, a config audit became three production promotions (prefix caching, fp8 KV, a doubled 703K-token pool), one spectacular-but-vetoed 4.35× decode win, two remembering psyches running side by side on a single consumer GPU — and five real bugs caught by a twin-lane canary loop before production felt any of them. Here is the method, the numbers, and everything that broke.

We rebuilt our Jungian multi-agent lab so each archetype carries its entire life — every situation, everything heard, everything said — as an append-only journal that fills a 228K-token context window on a 24 GB Radeon. The prompt is shaped so the whole life is one reusable prefix; when the window fills, the agents dream their oldest memories into a durable core. Here is the architecture, the numbers, and what broke along the way.

The quarterly snapshot of the whole stack: FlexInfer went multimodal, Mills merged its first autonomous work, a flight recorder appeared, and the dashboards grew a control plane. What shipped, what the numbers say, and what is deliberately not done.

FlexInfer had a "gaming mode" that had never once run a game. I killed the stub, proved the substrate with a 30-minute kill-test, and rebuilt it as a declarative GamingSession CR that drains inference and streams a GPU-accelerated game over Moonlight.

A served model can load at 96K context and still be useless past 64K. Loading is not the same as staying coherent. Here is how we mapped the exact cliff with a progressive needle-in-haystack bench — and why the limit was the model, not the GPU.

The next Loom Core orchestration layer turns roadmap intent into reviewed, gated, observable work. The internal codename was Hive; the product metaphor is moving toward Mills.

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.

How I would roll out AI-assisted development on a team that has not standardized: what to do in week one, what to earn the right to argue about later, and what almost always goes wrong.

What it took to get Gemma 4 E4B serving cleanly on Radeon through FlexInfer: a stable TRITON lane on a 7900 XTX, an experimental TurboQuant long-context lane on a second node, and the GPTQ pipeline work still underway.

AI-assisted development is useful leverage, but only if you convert borrowed competence into real judgment before the support becomes a dependency.

Treat your repo like a control system: instruction hierarchy, workflows, hooks, and shared memory that make AI-assisted dev fast, reproducible, and hard to derail.

How Loom keeps MCP servers and skills in sync across Codex, Claude, Gemini, VS Code, Antigravity, Kilocode, OpenCode, and Zed.

How to keep AI-assisted development fast and token-efficient: one proxy entry, a Go daemon that routes calls, and a small set of Go-native MCP servers.

How I redistributed 6 models across 3 GPU nodes to eliminate contention, using priority-based shared groups and label-based aliases for routing and failover.

How I run multiple OpenAI-compatible LLM endpoints on a small K3s cluster with AMD Radeon GPUs, and what I had to do to make it stable.

A case study in healthcare integration: how Source Profiles, a three-phase parsing pipeline, and a workflow DSL turn messy legacy formats into semantic events.

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 to define meaningful SLOs for production inference workloads, and what to do when they break.

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

A practical guide to running GPU workloads on-prem or hybrid, using Kubernetes and GitOps patterns that make operations boring.

Common GPU infrastructure failures in production and how to diagnose them before they become incidents.

Before you can cut GPU costs, you need to measure them correctly. Here is what to track and what the cloud console will not tell you.

A practical checklist for auditing production AI infrastructure: GPU cost baselines, reliability risks, and an executable roadmap.

A deep dive into optimizing Canvas 2D and Three.js visualizations for Kubernetes dashboards, covering algorithmic complexity, memory management, and GPU-efficient rendering patterns.

A real integration failure mode: when an API contract is implicit, patient matching becomes a risk management problem. Here is the defensive pattern (validation + contract tests + instrumentation) that makes it operable.

The infrastructure, product surfaces, and live demos behind the FlexInfer, Loom, and fi-fhir work I publish here.

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

What makes an AI agent reliable in production: explicit loops, bounded tools, and visible operator state.

How I built FlexDeck, a full-stack operations dashboard with real-time K8s monitoring, GitLab CI/CD visualization, and AI model management using Go and SolidJS.