Building an Offline-First Multilingual ePub & Audio Reader on Local Infrastructure

Self-hosted ePub reader running in dark mode on mobile and desktop with sentence highlights and audio controls

I have a confession. My Calibre library has 6,332 books in it, and for years I have been renting access to a bunch of reading apps instead of just reading them. Each one wanted a subscription, a login, or my reading habits. Then I wanted a voice to read my books aloud, and the cloud options wanted to bill me per character. That was the moment I decided to build my own reader.

Fun with the New IKEA Smart Devices

IKEA KAJPLATS bulb and BILRESA remotes communicating over Matter Thread mesh with Home Assistant

I picked up the new IKEA smart gear this week, and I have been grinning at it ever since. There is a KAJPLATS bulb, a GRILLPLATS outlet, and two flavors of BILRESA remote, a two-way switch and a scroll wheel. They speak Matter over Thread, they cost IKEA money instead of boutique money, and they drop straight into Home Assistant without a proprietary bridge. That alone would have been a fun weekend.

Then I read the quick-start card. IKEA clearly designed this for people who do not own a hub. You switch on the bulb, pop batteries into the remote, hold the two about two inches apart, and press the pairing button four times. They find each other and the remote just works. For a normal household that is genuinely great. No app, no account, no homework.

Giving My AI Agents Their Own Isolated Sandboxes So They Can Run Tests Without Breaking My Desktop

Miniature robotic AI assistants running test suites inside isolated glass sandboxes while the main workstation stays calm

     One of the most exciting moments in building with autonomous AI agents is when you graduate from simple text chat to letting the models actually run code. You give an agent a terminal tool, connect it to your workspace, and watch it run a test suite, spot a failing assertion, and edit the code to make it green. It feels like science fiction unfolding right in front of your eyes. But if you let that agent run those commands directly on your primary workstation, the honeymoon ends the first time a rogue script binds to port 8080, leaves six background processes hanging, or starts installing global system packages while you are in the middle of a video call.

     I ran into this exact dilemma as my local fleet of AI helpers grew. When an agent is refactoring a mobile application or verifying database queries, it needs to run real builds, execute Gradle tasks, and run hundreds of unit tests. Asking an AI model to write software without letting it run tests is like asking someone to bake a cake with their eyes closed; it might look fine from the outside, but you will not know if it actually works until you take a bite. At the same time, I really like having my desktop workstation stay fast, clean, and quiet. I did not want automated test runs gobbling up my CPU cores or filling my local drive with transient build caches while I was trying to get work done.

     The fix was to give my AI minions their own private playground. Instead of running test suites locally on my main desktop, I spun up dedicated sandbox environments on my homelab hypervisor. Whenever an agent finishes a code refactor and wants to test its work, it does not touch my workstation environment. It connects over SSH to a clean, isolated container running on the cluster, pulls the branch, and fires off the entire test suite there.

     Having isolated sandboxes completely changes how comfortable you feel letting autonomous agents experiment. In an isolated container, an agent can spin up a local database, run through 200 unit tests, wipe temporary files, and compile a fresh build without any risk to the host system. If a test hangs or runs out of memory, it only touches the disposable container. My primary desktop never drops a frame; the CPU fan never even spins up. Once the test run finishes, the agent grabs the console output, verifies that all assertions passed, and reports back with the clean diff.

     Setting up this kind of isolated testing setup turned what used to be a nerve-racking experiment into one of the most reliable parts of my homelab. If you want to configure your own hypervisor cluster to host isolated sandboxes and virtual machines, I put together a step-by-step guide on By Design Won't Fix showing how to set up a Proxmox VE homelab cluster and manage virtual machines with Terraform. Giving your coding agents their own sandboxes lets them move fast, break things in a safe container, and leave your daily workstation completely in peace.

Later,
     SteveO

Engineering a Toolless Snap-Fit Lamp Mount for Pegboards with AI CAD Modeling

IKEA Tertial lamp mounted to an IKEA Skådis pegboard using a 3D printed custom PETG bracket

Yesterday I told you about the new IKEA smart bulb, and that bulb needed a home. It lives in an IKEA Tertial architect lamp over my workbench, which is one of my favorite lamps ever. The only thing I do not love is the clamp it ships with. It eats edge space on my desk, blocks my cable routing, and wobbles every time I bump it.

Teaching My AI Assistant to Triage My Email Inbox and Surface Deadlines in Obsidian

Robotic AI assistant sorting inbox envelopes and pinning scheduled deadlines to a glowing Obsidian knowledge graph

     There is a specific kind of quiet panic that sets in when you realize your email inbox has accumulated eighty-four unread messages before you even finish your morning coffee (and no, clicking "mark all as read" does not count as a strategy). Most of those incoming notes are pure automated noise; shipping receipts, automated server newsletters, and service notifications that do not need any human attention at all. But buried somewhere inside that pile is usually the one message that actually matters - a reply from a recruiter asking for your availability tomorrow, a reminder about an expiring domain registration, or a project deadline you promised someone last Thursday. Trying to stay on top of that daily avalanche with traditional email filters always ends up being a fragile game of keyword whack-a-mole; either your rules miss the important reply completely, or they tuck an urgent scheduling thread into an obscure folder where you will not see it until next week.

     Because I run a local homelab with plenty of storage and compute, I decided to teach an autonomous AI agent to handle the morning triage for me. The idea was simple: instead of giving a third-party cloud service direct access to my inbox or relying on brittle regex scripts, I set up a headless container that mirrors incoming mail down to a local Maildir repository on my storage server. Once those raw messages are sitting on my local network (where they can be indexed safely without sharing email credentials or personal data with random cloud aggregators), I let a local AI agent run through the new files during my morning cron run. The agent scans the headers, parses the email body, and classifies what it finds into clean buckets like project updates, scheduling invitations, and general announcements.

     The really fun part is how the agent reports what it discovered. Instead of sending me another noisy email or pinging my phone with push alerts, it talks directly to my local Obsidian knowledge vault. It opens my daily note, cross-references any action items against my existing task lists (so I do not double-book myself or forget someone's question), and drops a neat daily briefing right under my morning plan. If a client asks for a phone screen by Friday, the agent extracts the deadline, adds a linked calendar note, and summarizes the context in two punchy sentences; meaning I can glance at my morning dashboard and immediately know what requires a response before my first meeting. It turns a chaotic inbox into an organized, actionable checklist before I even sit down at my desk.

     What makes this autonomous pipeline so dependable in practice is having a resilient model router running underneath it. When my local GPU is idle, the agent runs entirely against local open-weight models for zero API cost; but if my workstation is busy compiling code or running a long benchmark (which happens more often than I care to admit), the router automatically fails over to lightweight cloud endpoints so my morning briefing never misses a beat. If you want to build this kind of autonomous assistant for your own homelab workflows, I put together a step-by-step tutorial on By Design Won't Fix showing how to set up Hermes Agent locally with a LiteLLM router and free cloud fallbacks. Teaching an AI assistant to handle your inbox plumbing takes the stress out of mornings - leaving you free to focus on building cool stuff instead of drowning in notifications.

Later,
     SteveO

Using Local Open-Weight Models for Zero-Marginal-Cost Background Agent Tasks

A homelab GPU server humming quietly while local open-weight models handle round-the-clock background agent tasks with zero token bills

     If you run autonomous coding agents on your personal projects, you quickly discover that high-frequency background automation has an uncomfortable math problem. When you have dozens of background triage agents scanning git repositories, auditing pull requests, checking lint rules, and verifying daily system health checks, pointing every single routine request at frontier cloud APIs gets expensive fast. A single background polling loop firing dozens of times an hour can eat through a monthly API budget before you finish your morning coffee. So a couple of weeks ago, I moved the repetitive background grunt work down to a dedicated GPU on my homelab; and it completely transformed the economics of autonomous software development (which is basically just the cost of electricity in the basement).

     The division of labor turns out to be surprisingly straightforward. You do not need a frontier cloud reasoning model to check whether a git branch has uncommitted changes, summarize an error log, or verify that a configuration file points to the right local network port. Local open-weight models have gotten remarkably capable at structured tasks; running a solid 14-billion parameter coding model on a local workstation gives you fast, private inference with zero incremental token bills. The trick is treating local models like the tireless junior crew in a busy workshop; they handle high-frequency sweeps, formatting checks, and preliminary diff reviews all night long, only escalating tricky design choices or complex architectural problems up to the big cloud models when human intervention is actually needed.

     Running local models on a homelab server requires two different tools depending on what the agents are doing. When I want to swap models on the fly or test a specialized small model for a quick one-off script, Ollama is tough to beat. But when four autonomous agents wake up at the exact same second and fire concurrent review tasks at the inference endpoint, a single Ollama worker queue starts to choke (and yes, I will readily admit to being impatient when waiting on responses). That is where vLLM comes in; its continuous batching and memory management handle concurrent requests without breaking a sweat, turning a single desktop GPU into a true multi-tenant inference server for the entire house.

     Tying the homelab setup together took a little Docker plumbing, particularly setting up isolated container ports so a rogue background job does not unload an interactive coding model from video memory right while I am working in my editor (because watching an agent drop your model mid-sentence is an experience you only want to live through once). If you want to set up the same dual-engine layout on your own hardware, I wrote a step-by-step walkthrough on By Design Won't Fix covering how to configure Ollama in Docker with dedicated worker ports, along with setting up vLLM for high-throughput batching. Having both engines purring in Docker means my local bots can chew through hundreds of automated health checks and code audits every single day without a single per-token charge.

     There is a real sense of freedom that comes with knowing your automation is truly free to run. Instead of rationing prompts or worrying about a background loop inflating my credit card, I can let my AI minions run twenty-four hours a day, keeping my repositories tidy, catching flaky tests, and waking up every morning to clean summaries in my notebook (and my monthly credit card statement stays blissfully flat). Building a hybrid homelab setup where local open-weight models do the heavy lifting while cloud models stay in reserve takes a bit of initial tuning; but once the pieces click into place, running continuous automation with zero token anxiety is about the most satisfying upgrade you can give your developer workflow - it just works quietly in the background while I sleep.

Later,
     SteveO

Running a Multi-Model AI Writers' Room Where Claude, Gemini, and GPT Review Each Other's Work

Three frontier AI models collaborating around a digital drafting table to review manuscripts and catch blind spots in a multi-model writers room

     When you start building autonomous software agents, your first instinct is usually to pair with a single favorite frontier model and let it run wild. You give it a nice system prompt, hand it a workspace, and marvel at how quickly it drafts documents or writes Python scripts. But if you have ever asked that same model family to review its own work, you know the quiet letdown that follows. A model reviewing its own draft is like asking an author to proofread their own manuscript five minutes before deadline; it already knows what it meant to say, so it glides right past its own blind spots, stylistic quirks, and logical gaps with cheerful confidence. A few weeks ago, while coordinating a batch of complex technical case studies and multi-stage code pipelines across 3 different model families, I decided to treat the problem like a real television newsroom and built a multi-model writers room.

     The setup is straightforward: instead of letting one model run the entire show, I assign distinct responsibilities across three completely different frontier model families - pairing Claude, Gemini, and GPT in a structured two-round review loop. One model acts as the lead author and produces the initial first-round draft. Before that draft goes anywhere near production, two peer reviewer agents from the other two model families receive the text blindly and critique it independently. Claude might catch subtle reasoning leaps and edge cases that Gemini skimmed over; Gemini might point out missing contextual links or structural gaps that Claude missed; and GPT brings its own distinct eye for concise phrasing and strict logical boundaries.

     What makes this multi-model setup so fun is watching how the different model personalities complement each other. Each model family has its own unique training lineage, error distribution, and conversational tone. When you keep them in their own isolated review lanes, they do not suffer from the groupthink that happens when a single model grades its own homework. In round one, each reviewer writes down their concrete blockers, major suggestions, and minor stylistic nits into a separate critique file without editing the source document. The lead author reads both peer reviews side by side, incorporates the valid feedback into a revised second-round draft, and submits the revision for a final re-check.

     The difference in output quality between a single-model pass and a multi-model peer review is night and day. Subtleties that would normally slip past a lone agent - like an unexplained acronym, an unstated architectural dependency, or a tiny code snippet assumption - get flagged immediately by the peer reviewers. Because the review cycles are capped at two rounds, the process never devolves into an endless editorial debate. The author addresses the blockers, the reviewers verify the fixes, and an automated verification gate confirms all formatting and provenance rules before anything gets marked ready.

     If you want to set up this kind of collaborative pipeline on your own homelab, I wrote a step-by-step guide on By Design Won't Fix covering how to set up a Paperclip multi-agent organization to write and review code. Building a multi-model writers room turned what used to be a tedious manual editing bottleneck into one of the most exciting parts of my daily homelab routine; and watching three distinct frontier models work together to polish a draft feels like having a miniature editorial staff on call whenever inspiration strikes.

Later,
     SteveO