[Devember 2026] From Bazzite to Blackwell: Improving Flint on RTX Spark + Qwen on Bluefin:dakota Z13 / Strix Halo

Dev Zone Devember
1

AI Disclosure:

AI is both the research subject of this lab (evaluating and hardening distributed local inference runtimes) and an interactive pair-programmer via omp for config drafting, state-machine validation, and sanity-checking. All architectural decisions, driver plumbing, OCI isolation boundaries, and loop-prevention guardrails are manually audited, written, and verified by me—no blind “vibe coding” or unvetted generation loops.

[Devember 2026] From Bazzite to Blackwell: Improving Flint on RTX Spark + Qwen on Bluefin:dakota Z13 / Strix Halo

I was originally just looking at Bazzite to get better battery and sustained performance out of handheld gaming hardware. That spiraled directly into the wider Universal Blue / Project Bluefin ecosystem, which quickly led me down the rabbit holes of TunaOS and Hive Commons.

Along the way, I became very interested in the CNCF and container-first ecosystem, and I wanted to apply those principles directly to hosting and isolating local LLMs. Instead of relying on fragile host-level Python environments or uncontained runtimes, I wanted to apply OCI container isolation to orchestrate local models across disparate silicon.

My goal for Devember 2026 is to build a zero-cloud, physically distributed multi-agent system across local hardware, learn the low-level mechanics of these runtimes inside and out, and contribute practical recipes, bug fixes, and documentation back to the open-source projects that got me here.

The Architecture: Heterogeneous Silicon Across Two (or Three) Nodes

Instead of forcing multiple massive models to fight for memory allocations, thermal headroom, and driver bandwidth on a single box, this setup separates the primary compute engine from the real-time critic across distinct physical machines:


┌────────────────────────────────────────────────────────┐       ┌────────────────────────────────────────────────────────┐
│ Node 1: NVIDIA RTX Spark Workstation                   │       │ Node 2: ASUS ROG Flow Z13 / AMD Strix Halo 395+        │
│ (Primary Engine: Deep Synthesis & Code Generation)     │       │ (Advisor Engine: Fast Reflection & AST Audit)          │
│                                                        │       │                                                        │
│ • ARM64 SBSA CPU (20 Worker Threads)                   │       │ • High-Density Mobile Silicon / APU Unified Memory     │
│ • Blackwell GPU (SM 12.1a, 6144 Cores)                 │       │ • OS: Project Bluefin (bluefin:dakota atomic sandbox)  │
│ • 101.4 GiB Unified LPDDR5x DRAM (Zero-Copy)           │       │ • Serving Engine: Strata                               │
│ • OS: Windows 11 ARM64 + WSL2 Fedora 45 (wslc)         │       │ • Model: Qwen 3.8 Flash Next (Unsloth 4-bit quants)    │
│ • Primary Model: Flint NVFP4 (~39.8B, 21.21 GiB)       │       │ • Endpoint: Bound to Tailnet via Strata                │
│ • Hive Commons Sandboxed OCI Container (127.0.0.1:8080)│       │                                                        │
└───────────────────────────▲────────────────────────────┘       └───────────────────────────▲────────────────────────────┘
│                                                                │
└───────────────────────────────┬────────────────────────────────┘
│
[Tailnet (WireGuard / TLS 1.3)]
│
┌───────────────▼──────────────┐
│ Host Orchestrator: omp       │
│ State Machine & Loop Defense │
└───────────────┬──────────────┘
│ (Stretch/Part 3 Fabric)
┌───────────────▼──────────────────────────────┐
│ Node 3: Dedicated Compute / PCIe Switch Box  │
│ • AMD Ryzen 9 7950X3D (128 GiB DDR5)         │
│ • HighPoint Rocket PCIe Switch (PEX89048)    │
│ • RTX 5090 + RTX 3090 Dual Accelerator Array │
└──────────────────────────────────────────────┘

Node 1: The Heavyweight — NVIDIA RTX Spark

  • Role: Primary generator, deep contextual reasoning, full-file synthesis, and macro-planning.
  • Hardware: 6,144-core Blackwell SM 12.1a GPU paired with 101.4 GiB of unified system memory over a shared zero-copy bus.
  • Software Stack: Windows 11 ARM64 host paravirtualizing through /dev/dxg directly into CUDA 13.5 user-mode drivers inside a Fedora 45 OCI microVM (wslc).
  • Model Stack: RecursiveSI/flint-nvfp4-gguf (~39.8B params, 21.21 GiB weight buffer) served via native SBSA llama-server.
  • Current Baseline: Clocking >70 tok/sec sustained decode with a 0.31s TTFT across a 65,536 context ceiling.

Node 2: The Fast Critic — ASUS ROG Flow Z13 / AMD Strix Halo 395+

  • Role: Sub-second reflection, JSON schema linting, AST syntax verification, and sanity-checking Flint’s proposals before execution.
  • Hardware: Compact, high-density mobile silicon—ASUS ROG Flow Z13 or AMD Strix Halo (Ryzen AI Max+ 395) with high-bandwidth unified memory.
  • Software Stack: bluefin:dakota—an atomic, immutable developer workstation image from Project Bluefin (Universal Blue) with containerized toolchains and hardware acceleration out of the box.
  • Model & Serving: Strata serving Qwen 3.8 Flash Next utilizing Unsloth dynamic quants and custom inference kernels for rapid token generation.
  • Network Binding: Strata is published directly onto our private Tailnet (Tailscale mesh with MagicDNS), enabling secure, authenticated cross-machine discovery without opening raw LAN ports.

Node 3 (Stretch / Exploratory): Dedicated Compute & PCIe Switch Fabric

  • Role: High-throughput batch worker, heavy model critic offload, or external accelerator backplane.
  • Hardware: AMD Ryzen 9 7950X3D, 128 GiB DDR5, HighPoint Rocket PCIe Gen 5 Switch host card (Broadcom PEX89048), hosting discrete RTX 5090 and RTX 3090 GPUs.
  • Investigation: Evaluating whether this serves best as a third network-addressable inference tier or as an external PCIe/OCuLink switched eGPU compute pool tied directly into the Spark or Z13.

The Brain: omp (oh-my-pi) Orchestration

omp coordinates the state machine:

  1. Receives the objective and dispatches the task to Flint on the RTX Spark.
  2. Streams reasoning steps and proposed code diffs.
  3. Automatically routes AST validation and critical reflection requests over the Tailnet to Strata (Qwen Unsloth on the Z13 / Strix Halo node).
  4. Enforces strict loop termination criteria before allowing any local tool execution.

What I’m Tackling

1. Hosting & Improving Flint on Blackwell Silicon

Flint is a ~40B parameter dense model that punches above its weight, but requires deliberate runtime tuning on newer architectures:

  • Container Hardening: Adhering strictly to Hive Commons isolation standards—mounting model weights strictly read-only (:ro), completely eliminating egress at the binary level (-DLLAMA_CURL=OFF), and restricting scratchpads to noexec, nosuid tmpfs.
  • Kernel & Context Tuning: Profiling NVFP4 quantization loss and attention head performance under long context saturation (up to 65k tokens) on Blackwell SM 12.1a execution paths.

2. Bringing Strata into the bluefin:dakota Sandbox

Running the secondary advisor node on bluefin:dakota brings the stability of atomic desktops directly into an AI inference pipeline:

  • Isolate Strata and Unsloth dependencies in a clean, reproducible container without polluting the host OS image.
  • Maintain predictable compute and thermal behavior on standalone mobile silicon and APUs.
  • Expose Strata cleanly over the Tailnet so the RTX Spark can query the critic regardless of physical topology.

3. Cross-Node Latency over Tailnet

When an agent loop requires multiple back-and-forth review turns per tool execution, network transport latency adds up quickly:

  • Profiling the overhead of Tailnet WireGuard transport vs direct local socket/LAN links.
  • Determining whether streaming responses chunk-by-chunk across the network pays a noticeable latency tax compared to batched diff inspection.

4. Taming the Multi-Agent Echo Chamber

The most notorious bug in multi-agent systems is the runaway critique loop:

  1. Model A generates code with a minor bug.
  2. Model B nitpicks something irrelevant.
  3. Model A apologizes, rewrites the code worse, and introduces two new bugs.
  4. Model B approves the broken code because the context got poisoned.

We’re implementing hard state-machine guardrails in omp: strict iteration caps, automated context window compaction between review rounds, divergence scoring, and emergency circuit breakers to kill loops before they spin out of control.

Giving Back: Upstream Contributions & Goals

I don’t just want a cool rig sitting on my desk; I want to turn what I learn into real contributions back to the community:

  • Universal Blue / Bluefin: Document and publish container configurations and developer sandbox recipes for running local AI inference engines (Strata / Unsloth) seamlessly on bluefin:dakota.
  • Hive Commons: Validate and contribute back real-world testing data on container isolation compliance, tmpfs scratch behavior, and egress-free binary compilation.

Project Milestones

  • Milestone 1: Spark Baseline & OCI Hardening
    • Solidify the automated mise workflow for the Flint NVFP4 container on the Spark.
    • Benchmark baseline decode velocity (tok/sec), TTFT, and thermal behavior under full 65k context saturation.
  • Milestone 2: Z13 / Strix Halo bluefin:dakota & Strata Deployment
    • Provision the bluefin:dakota sandbox on the Z13 / Strix Halo 395+ node.
    • Deploy Strata serving Qwen 3.8 Flash Next (Unsloth) over Tailnet.
    • Benchmark token velocity, latency, and thermal throttling under sustained query bursts.
  • Milestone 3: omp Cross-Node Pipeline & Loop Defenses
    • Wire omp to execute the dual-node loop: Spark generates → Z13 / Strix Halo critiques → Spark patches → Tool executes.
    • Stress-test loop prevention circuit breakers with intentionally broken codebases and adversarial prompts.
  • Milestone 4: Flint Improvement & Cross-Node Benchmarks
    • Optimize Flint’s sampling parameters, system prompts, and tool-calling schemas.
    • Profile network overhead (Tailnet WireGuard latency vs local socket) and analyze NVFP4 accuracy vs Qwen’s Unsloth outputs.
  • Milestone 5 (Stretch): HighPoint PCIe Switch & Discrete Accelerator Array
    • Bring up the AMD 7950X3D / HighPoint Rocket switch / RTX 5090 + 3090 rig.
    • Benchmark cross-chassis eGPU / switched PCIe performance vs network-bound Tailnet RPC.
  • Milestone 6: Retrospective & Upstream Deliverables
    • Publish full architectural benchmarks, failure logs (“what broke and how I fixed it”), configuration files, and upstream documentation PRs.

Code, Configs, and Following Along

The container definitions, scripts, mise.toml task automation, and omp model definitions are open source and tracked on GitHub:

:backhand_index_pointing_right: Repository: https://github.com/thatguywob/rtx-spark-flint-sandbox

I’ll be dropping updates right here in this thread with status update & bugs I stumble into.

Happy Devember!