Building a Self-Hosted Software Factory, Hotio Plex Woes, and the Price of Letting Agents Loose

Homelab Highlights for 2026-08-12: self-hosting and homelab notes worth knowing.

[Audio embed placeholder]

News Roundup

Problems with hotio’s latest Plex release-727d8ac?

A user reports that updating to a specific Hotio Plex container release caused immediate bandwidth warnings and playback issues on local streams, which were resolved by rolling back to the previous version.

Why it matters: It’s a reminder to be cautious with container updates, even from trusted sources, and highlights the value of version pinning in a homelab media server setup.

Source: github.com

Self-Host Weekly (21 August 2026)

The weekly newsletter covers self-hosting news, including a link to a large-scale hard drive reliability study from Backblaze data and a highlight of a new self-hosted media tracker called Floppy.

Why it matters: It aggregates useful data for homelab planning, like storage purchase decisions, and surfaces new tools like Floppy that integrate with existing media server ecosystems.

Source: selfh.st

Running AI agents in GitHub Actions with Docker Sandboxes

GitHub’s Agentic Workflows now support Docker Sandboxes (sbx) as a runtime, allowing AI coding agents to run in isolated microVMs with private Docker daemons within CI pipelines.

Why it matters: This brings strong isolation for untrusted agent code into a major CI platform, enabling safer automated testing, bug fixes, and pull request generation directly from workflows.

Source: Docker

Three ways to smuggle SQLite into Nix

A technical exploration of different methods for integrating SQLite into Nix-based development and deployment environments.

Why it matters: For users of Nix, it provides practical patterns for managing dependencies and embedding databases, which is relevant for reproducible builds and self-hosted application deployment.

Source: Hacker News

Tool & Software Highlight: Building an (almost) fully self-hosted, sandboxed, agentic software factory

A detailed blueprint for a development loop where AI agents write and test code, with the only external dependency being source control. The setup runs Llama 3.2 models locally using Ollama and executes code in isolated Docker Sandboxes (microVMs) on the user’s own hardware.

Why it matters: It demonstrates a practical, high-isolation approach to experimenting with agentic workflows without relying on cloud APIs, highlighting the hardware requirements and trade-offs of a truly self-contained system.

Source: Hacker News

One Thing to Try

Sources

Transcript

Host A: Welcome to Homelab Highlights, the show that surfaces practical homelab wins and useful self-hosted tools.

Host A: Alright, we’re kicking off with a blog post that gets into the nitty-gritty of building a self-hosted, sandboxed, agentic software factory. Jake Saunders posted a deep dive into his setup where AI agents can write and test code, but keep almost everything running locally. [curious] The goal was ambitious: create a development loop where the only external dependency is source control on GitHub. Everything else, from the model inference to the execution sandbox, runs on his own hardware.

Host B: Yeah, and the hardware requirement isn’t trivial. He’s running Llama 3.2 models locally—specifically the 90B Vision and 11B Text models—using Ollama. That means a 4090 GPU for the vision work and a 3090 for text processing. The execution environment is where it gets really interesting: Docker Sandboxes, or sbx. These aren’t your regular containers; they’re microVMs with a private Docker daemon. So the agent gets sudo and broad shell access inside its sandbox to spin up Testcontainers and run builds, but the host system stays completely isolated. Saunders details using WireGuard to network the components securely, which keeps the potential blast radius small if something goes wrong.

Host A: The blog post walks through the specific Docker commands to create that sandbox with the right capabilities, like --cap-add=ALL and --security-opt seccomp=unconfined inside the microVM. He’s open about the tradeoffs too: the hardware commitment is significant, and there’s added latency from the sandbox layer. Managing GPU memory between the different models is another practical challenge. But as a blueprint for experimenting with agentic workflows without shipping everything off to a cloud API, it’s a fascinating look at what a truly self-contained development loop might look like. That ‘almost’ in the title really does a lot of work.

Host A: First up in the feed: a quick warning for anyone using the Hotio Plex container. A user on GitHub reported that updating to the release tagged 727d8ac caused immediate bandwidth warnings on their local streams. AppleTV and MacOS clients both started complaining, with the bandwidth monitor spiking to over 100 Mbps for a single 1080p stream. Rolling back to the previous release, 664ca4c, fixed it completely. [thoughtful] The thread doesn’t have a root cause yet, but one commenter suggested checking if playback sessions switched from Direct Play to transcoding. Worth pinning that older version if you’re on Hotio—it’s a solid reminder that even trusted container sources can have a bumpy release.

Host B: Next, several items surfaced in the latest Self-Host Weekly newsletter. One original piece it linked to is Tom’s Hardware reporting on a peer-reviewed study that analyzed Backblaze’s data on 443,000 hard drives over 1.66 million drive-years. According to the article, HGST drives were ranked most reliable, with Toshiba and Seagate drives failing at roughly twice the rate of WD and HGST. That’s a huge dataset for anyone planning storage purchases. The newsletter also highlighted a new self-hosted media tracker called Floppy, pitched as an alternative to Trakt or Letterboxd. It handles movies, TV, books, games, and can sync with Plex or Jellyfin. It’s a Docker deployment that needs a separate Redis container. The developer says it’s built with Go and SvelteKit, and the GitHub repo shows about 300 stars already.

Host A: And Docker’s blog has a post about a new integration. GitHub’s Agentic Workflows now support Docker Sandboxes, or sbx, as a runtime environment for AI coding agents in CI. This means you can configure a workflow where an agent runs inside a microVM sandbox on a GitHub Actions runner, with its own private Docker daemon to do things like run Testcontainers tests. The post walks through a demo where the agent finds and fixes a bug in a Java app, then opens a draft pull request. The setup uses the gh-aw CLI extension. It’s interesting to see this sandboxing tech, which we just talked about in that homelab context, becoming a first-class citizen in a major CI platform. The blog post specifically calls out that this provides stronger isolation than a regular container, which is the whole selling point for running untrusted agent code.

Host A: Let’s take a closer look at that Floppy project from the newsletter. It’s a single, unified interface for tracking movies, TV shows, anime, books, games, music, and podcasts. The feature set includes watch history, statistics, shareable lists, and tracking what media you actually own. For automation, it has sync integrations with Plex, Jellyfin, and Audiobookshelf. It pulls metadata from sources like TMDB, IGDB, and Open Library, so your collection gets populated with posters and details automatically. The developer mentions it supports OAuth for user logins, so you can have multiple family members with their own tracked profiles, which is a nice touch.

Host B: The deployment story is straightforward: a Docker container plus a separate Redis instance, which you could also run as another container. The GitHub readme says it can be easily deployed via Docker Compose. For a homelab, it fits right into the media server ecosystem, sitting alongside your Plex or Jellyfin server as a dedicated tracker. It’s an open-source alternative to closed services like Trakt, so you keep all that viewing data and habits in-house. Whether that’s worth the extra container depends on how deep into stats you want to get. The developer notes it’s still in early development, but the core tracking and syncing features appear to be functional. One operational detail from the docs: you need to set up a cron job or similar to trigger the periodic sync with your media servers, it’s not a live push. [conversational] That’s a small bit of extra setup, but it keeps the architecture simple.

Host B: Finally, a community story from someone who gave Claude Fable a domain and a simple instruction: build whatever you want. As they recounted on Reddit, the agent built a site called 1f916.ai, a platform where AI agents can register, interact, and build things, with humans mostly watching. The original post about the experiment got a lot of attention. The Redditor, ‘agent_curious’, described the process as watching the agent make architectural decisions, write all the code, and deploy it to Cloudflare Pages and Workers. The agent even set up a database using D1 and implemented user authentication, which is a non-trivial amount of work.

Host A: Two weeks later, they checked the Cloudflare bill. [with emphasis] They posted the infrastructure numbers, which show what it actually costs to host a site that gets significant traffic from an agent-built project. The bill showed usage across Workers, Pages, R2 storage, and AI inference, giving a breakdown of where the money goes. It’s a real-world data point on the expense of running something like that, even with the agent doing the initial heavy lifting. The lesson seems to be that turning an agent loose can have surprising operational costs down the line, a useful reminder before setting any automated builders free on a public-facing domain. It’s one person’s experience, but it highlights the gap between a cool demo and a sustainably hosted project. The Redditor noted the AI inference costs were the most unpredictable part, which tracks given how pricing for those API calls can scale. That unpredictability is something operators should factor in.

Host A: That’s Homelab Highlights for Wednesday. Until next time, happy hosting!