Hullabalooing

It Turns Out My Router Was a National Security Decision

Mon, 23 Mar 2026 18:00:00 -0600

In March 2026, the FCC designated all consumer routers manufactured outside the United States as a national security risk, banning new foreign-made models from sale.¹ Eero, NetGear, and Google Nest are all affected, not just Chinese manufacturers, because they all produce hardware overseas.

The reasoning in the FCC’s National Security Determination is specific. Three Chinese nation-state operations, Volt Typhoon, Flax Typhoon, and Salt Typhoon, used compromised consumer routers to build botnets targeting US critical infrastructure: communications, energy, transportation, and water systems. The FBI and DOJ shut down one of these botnets in 2024. The ban follows directly from those incidents.²

Three Production Apps, Zero Code: What Keip Actually Looks Like in Practice

Fri, 13 Mar 2026 00:00:00 -0600

Three Production Apps, Zero Code: What Keip Actually Looks Like in Practice#

In the past month I shipped three integration apps to my home cluster: a Spanish translator that replies in audio, a health tracking bot I can query from any room in my house, and a camera alert system that decides for itself what’s worth telling me about. Each one took under an hour to have running. None of them required me to write a single line of application code.

My Data, My Stack

Sat, 07 Mar 2026 00:00:00 -0700

I want to introduce a concept I’ll be coming back to throughout this blog: Personal Data Sovereignty, or PDS. It’s the idea that individuals can and should have meaningful control over where their data lives, who can access it, and what happens to it. Not as a legal right, as something you actually build.

If you’ve been reading this blog for a while, some of what follows will look familiar. I’ve written about the network setup, the GPU server, the second brain, the AI inference stack. This post isn’t about new technical ground, it’s more philosophical. PDS is the concept I’ve been building toward without naming it directly, and I wanted to put it in one place before the series goes any further.

I Pushed Local LLMs Harder. Here's What Two Models Actually Did.

Mon, 02 Mar 2026 00:00:00 -0700

In Part 1 of this series, I set up Claude Code against local LLMs on dual MI60 GPUs and watched it scaffold a Flask application from scratch. Small tasks worked. Complex ones did not. I ended with three ideas I wanted to test: running a dense model, trying Claude Code’s agent teams feature, and building a persistent memory layer for coding sessions.

I started the experiment that mattered most: giving a local LLM a project with real scope and seeing what happened. I ran the same project against two different models. The results were instructive, and not in the direction I expected.

Enterprise Integration Patterns Aren't Dead; They're Running on Kubernetes and Orchestrating AI

Tue, 24 Feb 2026 00:00:00 -0700

Enterprise Integration Patterns Aren’t Dead; They’re Running on Kubernetes and Orchestrating AI#

Keip is a Kubernetes operator for Enterprise Integration Patterns. Gregor Hohpe and Bobby Woolf documented these patterns in 2003: content-based routers, message transformers, splitters, aggregators, dead letter channels. Spring Integration has implemented them for years, but deploying Spring Integration on Kubernetes has always been harder than it should be. Keip fixes that. It turns integration routes into native Kubernetes resources, and I use it to run an LLM-powered media analysis pipeline on my home cluster.

I Ran Claude Code on Local LLMs for a Month. Here's What Worked for Me.

Mon, 16 Feb 2026 00:00:00 +0000

I have been running local LLMs on dual AMD MI60 GPUs for over a year, and recently pointed Claude Code at them to see how close I could get to frontier-quality agentic coding on my own hardware. I wanted to know: how close can local models actually get to Anthropic’s Claude for building real software?

This is the first post in a series documenting that experiment. Future posts will cover specific agentic coding sessions, hardware and model setup, and the tools I am building to close the gap.

I Built an AI Health Coach That Actually Knows Me

Wed, 11 Feb 2026 00:00:00 -0700

Every health app wants to coach you, but none of them know you. They do not know your baseline. They do not know that your blood pressure spikes after certain meals, or that your ketones tank when you are stressed. They offer generic advice based on population averages and call it personalized.

So I built my own. It runs on my infrastructure, stores everything in a time-series database I control, and uses Claude to understand what I am eating, estimate the macros, and give me context on every measurement I log. Not generic advice. Insights based on my data.

A Second Brain That My AI and I Share

Fri, 30 Jan 2026 00:00:00 +0000

My AI assistant and I share the same brain. Not metaphorically, we literally read and write to the same knowledge base. When I update a project note in Emacs, Nabu (my AI) sees the change. When Nabu logs something it learned, I see it in my daily file. This post is about how it works.

How It Works#

Nabu connects to my self-hosted Matrix server and it has access to my org-roam knowledge base via an MCP server I built. But it’s not just access, it’s integration. Nabu treats org-roam as its source of truth:

Why Your News Feed Feels Coordinated

Thu, 29 Jan 2026 13:20:00 +0000

Some years ago, I started to notice on Facebook that friends, family members, people I had not talked to in years, all posting the same arguments using nearly identical phrasing. Not just agreeing on issues, which is normal, but using the same specific words and framing. They had clearly heard it somewhere, probably cable news or talk radio, and were repeating it verbatim.

Sometime later, I started to see news reports about foreign propaganda campaigns. Russian troll farms, Chinese state media, Iranian influence networks. The pattern I noticed on Facebook was not just me being paranoid.

Task-Decoupled Agents: Breaking the Monolithic Context Problem

Thu, 22 Jan 2026 13:30:56 +0000

A recent paper from Tsinghua and Renmin University caught my attention: Task-Decoupled Planning for Long-Horizon Agents. The core insight resonated with a problem I’ve been wrestling with on a Java code modernization project at work, and I think the pattern deserves more attention.

The Entangled Context Problem#

Most LLM agent architectures fall into two camps: step-wise planning (reactive, one step at a time) or one-shot planning (generate the whole plan upfront). Both share a fatal flaw: they maintain a monolithic reasoning context that spans the entire task history.

Building a Voice-First Cyberdeck with the Jetson Orin

Wed, 21 Jan 2026 18:30:00 +0000

I had an NVIDIA Jetson Orin Nano sitting around collecting dust, along with a 5-inch touchscreen monitor, and thought it would be fun to build a voice interface for my second brain. Not because I needed one, but because the idea of talking to a device with an oscilloscope-style voice visualization seemed like a cool weekend project.

Why Build a Cyberdeck?#

Honestly, I just thought it would be neat. I had the parts, I had the time, and the concept of a voice-first chat device in a custom enclosure sounded fun to build. I had no productivity goals, no problem to solve, just a project for the sake of building something interesting.

Building a Mobile Interface for My Second Brain with n8n and Matrix

Wed, 21 Jan 2026 14:00:00 +0000

My org-roam knowledge base is the center of how I think and work. But it lives in Emacs, which means I can only capture ideas when I’m at my computer. I wanted a way to feed my second brain from anywhere, using just my phone—but I refused to put my notes in someone else’s cloud. The solution had to be entirely self-hosted. What I built combines Matrix for messaging, n8n for orchestration, and an MCP server that bridges to org-roam, all running on my own infrastructure.

ComfyUI on MI60

Wed, 21 Jan 2026 00:00:00 -0700

Node-based Stable Diffusion UI with AMD MI60 GPU acceleration via ROCm.

Overview#

ComfyUI runs as a containerized service using a custom ROCm 5.7 image built for the MI60’s gfx906 architecture. It can run standalone on both GPUs or alongside vLLM in the image-chat configuration.

Quick Start#

# Build the container image
cd comfyui
make build

# Start ComfyUI (standalone, both GPUs)
make up

# Or use the image-chat config (vLLM on GPU0, ComfyUI on GPU1)
curl -X POST -H "Content-Type: application/json" \
  -d '{"config":"image-chat"}' http://localhost:9100/switch

Access the UI at http://localhost:8188.

GPU Configuration Management

Wed, 21 Jan 2026 00:00:00 -0700

Dynamic switching between GPU configurations based on workload needs.

Overview#

Rather than running a single fixed configuration, I dynamically switch between GPU configurations. A Python service manages the transitions via HTTP API.

Available Configurations#

Config	Model	Use Case
`big-chat`	Llama 3.3 70B (TP=2)	Maximum quality chat
`coder`	Qwen3 32B (TP=2)	Coding tasks with thinking mode
`dual-chat`	Qwen3 8B + 14B	Two models, different tasks
`image-chat`	Qwen 7B + ComfyUI	Text + image generation

Configuration files are stored as compose YAML files.

GPU Metrics and Monitoring

Wed, 21 Jan 2026 00:00:00 -0700

Prometheus metrics and Grafana dashboards for GPU health and state monitoring.

Prometheus Metrics#

The gpu-state-service exposes Prometheus metrics on port 9100:

# GPU state and configuration
gpu_config_info{config="big-chat",model="llama-3.3-70b"} 1
gpu_state_info{state="ready"} 1
gpu_ready 1
gpu_config_switches_total 5
gpu_config_uptime_seconds 3600

# Temperature monitoring (from separate AMD GPU exporter on port 9101)
amd_gpu_temperature_junction_celsius{gpu="0"} 72
amd_gpu_temperature_junction_celsius{gpu="1"} 75
amd_gpu_utilization_percent{gpu="0"} 85
amd_gpu_power_watts{gpu="0"} 180

Prometheus Endpoints#

Port	Service	Metrics
9100	gpu-state-service	Config state, switches, uptime
9101	AMD GPU exporter	Temperature, utilization, power
9102	NVIDIA GPU exporter	RTX 2080 metrics (if present)

Temperature Alerts#

The service monitors junction temperatures and sends ntfy notifications:

MI60 Hardware Setup

Wed, 21 Jan 2026 00:00:00 -0700

How to get an AMD Instinct MI60 running for AI workloads, including cooling solutions, BIOS settings, and fan control.

Introduction#

The AMD Instinct MI60 is a powerful server GPU featuring 32 GB of HBM2 VRAM and PCIe 3.0 connectivity. It remains a good choice for budget-conscious AI developers looking for high VRAM capacity at a fraction of modern GPU prices. With proper setup, the MI60 can handle local LLM inference, Whisper transcription, Stable Diffusion, and other workloads.

vLLM Inference on MI60

Wed, 21 Jan 2026 00:00:00 -0700

Production inference using vLLM with tensor parallelism across dual MI60 GPUs.

Why vLLM?#

After evaluating Ollama, llama.cpp, and vLLM for MI60 inference, vLLM emerged as the best choice:

Tensor Parallelism: Native support for splitting large models across multiple GPUs. With dual MI60s (64GB total), I can run 70B parameter models that wouldn’t fit on a single GPU.
PagedAttention: More efficient memory management, allowing higher GPU utilization (90%) without OOM errors.

Publishing with Org-roam and Hugo

Tue, 20 Jan 2026 00:00:00 +0000

Most publishing systems treat writing and publishing as separate activities. You draft in one tool, then copy content into a CMS, tweak formatting, and hit publish. The writing environment and the publishing system are disconnected by design.

I wanted something different: a system where publishing is just another view of my thinking. Where the same notes I write for myself can become public posts with minimal friction. Where the blog is an extension of my knowledge base, not a separate silo.

Running Claude Code with Local LLMs via vLLM and LiteLLM

Tue, 20 Jan 2026 00:00:00 +0000

Every query to Claude Code means sending my source code to Anthropic’s servers. For proprietary codebases, that’s a non-starter. With vLLM and LiteLLM, I can point Claude Code at my own hardware - keeping my code on my network while maintaining the same workflow.

The Architecture#

The trick is that Claude Code expects the Anthropic Messages API, but local inference servers speak OpenAI’s API format. LiteLLM bridges this gap. It accepts Anthropic-formatted requests and translates them to OpenAI format for my local vLLM instance.

Building a Second Brain in Emacs with Org-roam

Mon, 19 Jan 2026 00:00:00 +0000

I’ve been building what I call my “Second Brain,” an Emacs-based knowledge management system that doesn’t just store notes, but actively helps me think. It’s built on org-roam, extended with semantic search via vector embeddings and proactive surfacing of relevant information. The goal isn’t to replace my thinking but to augment it, surfacing connections I might miss and nudging me toward follow-ups I’ve forgotten.

Why Emacs and Org-roam#

Before diving into what I’ve built, it’s worth explaining the foundation I chose.

Data Sovereignty and My Network Router

Sun, 18 Jan 2026 00:00:00 -0700

Consumer routers frustrated me for years before I understood why. It wasn’t the hardware; my ASUS RT-AC5300 was perfectly capable for most tasks. It was the assumption baked into every consumer device: that I didn’t need to see what was happening on my own network.

At some point, I wanted my router to do something it wouldn’t do. I don’t even remember what it was now. I tried open-source firmware, which worked for a while, until I hit another wall. Underpowered CPUs, limited RAM, confusing web interfaces, and the general lack of configurability.

An Affordable AI Server

Sat, 17 Jan 2026 00:00:00 -0700

Two AMD MI60s from eBay cost me about $1,000 total and gave me 64GB of VRAM. That’s enough to run Llama 3.3 70B at home with a 32K context window.

When I started looking into running large language models locally, the obvious limiting factor was VRAM. Consumer GPUs top out at 24GB, and that’s on an RTX 4090 at the high end. I wanted to run 70B parameter models locally, on hardware I own.