Agentic Factories, Plex Pitfalls, and a Self-Hosted Media Tracker

Homelab Highlights for 2026-08-19: 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 the hotio Plex container to a specific new release caused bandwidth errors during local playback, which were resolved by rolling back to the previous version.

Why it matters: It’s a reminder to monitor container updates and be prepared to pin versions when issues arise, even from trusted sources.

Source: GitHub

Self-Host Weekly (21 August 2026)

The newsletter covers a peer-reviewed Backblaze drive reliability study, the release of Spotify’s headless Soloist client, Debian’s vote on AI-assisted contributions, and highlights the Floppy media tracker.

Why it matters: It aggregates key data and tool releases relevant to homelab infrastructure, storage decisions, and self-hosted software.

Source: selfh.st

Running AI agents in GitHub Actions with Docker Sandboxes

A guide on using Docker Sandboxes (microVMs) as a runtime for AI agents in GitHub Actions, providing isolation while allowing agents to run tests, fix code, and open draft pull requests.

Why it matters: It demonstrates a secure pattern for integrating powerful, autonomous AI agents into CI/CD pipelines with controlled access.

Source: Docker

Three ways to smuggle SQLite into Nix

A technical blog post exploring methods for embedding SQLite within Nix package builds.

Why it matters: It highlights packaging techniques and workarounds for developers working with Nix and embedded databases.

Source: Hacker News

Decayfmt – a file format that corrupts itself a little every time you open it

A conceptual file format designed to degrade its own data slightly with each access, created as an experiment.

Why it matters: It’s a novel, if impractical, exploration of digital entropy and data persistence concepts.

Source: GitHub

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

A detailed blueprint for a local AI agent system that writes and tests code, using Ollama for models and Docker for sandboxing, running on hardware like an RTX 4090 with 64GB of RAM.

Why it matters: It provides a practical template for homelabs aiming to run autonomous coding agents in-house, focusing on containment and minimizing external dependencies.

Source: Jake Saunders

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: So, building a fully self-hosted AI agent that can write and test code [thoughtful]—sounds like a cloud service dream, right? But a detailed blog post from Jake Saunders walks through what an ‘almost’ fully self-hosted, sandboxed agentic software factory actually looks like. The core idea is to keep the models, the execution environment, and the version control all in-house, using Ollama for local model serving and a custom orchestration layer. The article mentions this is running on a machine with 64GB of RAM and an RTX 4090, which gives a sense of the hardware needed for serious local inference.

Host B: Yeah, the ‘almost’ is doing a lot of work there. The sandboxing is done with Docker—each agent task runs in its own container with limited network access and filesystem permissions. So if an agent goes off-script, it’s contained. For a homelab, the interesting part is mapping this blueprint to existing infrastructure. The article points out some components might still need external calls, but the goal is to minimize that surface. He specifically talks about using a read-only filesystem for the agent’s workspace and binding in only the tools it needs. [conversational] The biggest challenge noted is getting local models to perform complex reasoning as well as the cloud giants. His suggestion? Start with smaller, specialized models for specific tasks rather than trying to replicate a full general-purpose assistant locally.

Host B: First up, a quick note for anyone using the hotio Plex container. A user reported that updating to release-727d8ac caused bandwidth errors during local playback. Rolling back to the previous version, 664ca4c, fixed it. The suggestion in the thread is to pin that older version for now and check server logs—the issue might be a transcode failure masquerading as a bandwidth problem. [lighter] A good reminder that even trusted container sources can have a bumpy update.

Host A: Shifting to data, Self-Host Weekly highlighted a Tom’s Hardware study—a peer-reviewed analysis of over 443,000 Backblaze hard drives. According to that study, HGST ranked as the most reliable and Toshiba the least. Seagate and Toshiba drives failed at roughly twice the rate of WD and HGST over 1.66 million drive-years. For homelab storage decisions, that’s some serious long-term data.

Host B: Also from that newsletter, Spotify released Soloist, a new Spotify Connect terminal client for headless and DIY setups. It runs on Raspberry Pis and Linux, and works with both Free and Premium accounts. And Debian has opened a vote on how to handle AI-assisted contributions, which could set a precedent for other open-source projects. The project is calling it a ‘general resolution’ and it includes several options, from requiring disclosure to prohibiting AI-generated code in certain contexts.

Host A: For the tool highlight, there’s Floppy, a self-hosted media tracker featured in Self-Host Weekly. It’s pitched as an alternative to services like Trakt or Letterboxd. It gives you a unified grid interface to track movies, TV, anime, books, games, music, and podcasts all in one place, pulling metadata from sources like TMDB and IGDB. The developer built it out of frustration with scattered tracking lists and wanted a single, private hub.

Host B: The features include watch history, stats, shareable lists, and tracking what media you actually own. The interesting bit for a homelab is the sync integrations. [with emphasis] It can connect to Plex, Jellyfin, and Audiobookshelf to automatically update your watch history using webhooks. Deployment is via Docker, and it needs a separate Redis or compatible in-memory cache container. The documentation shows a Docker Compose example and notes it’s still in early stages, but that active sync feature is a big draw for automation. It sits alongside your media stack, adding a layer of organization without replacing the players themselves.

Host B: Finally, a community story that serves as a real-world cost check. A Reddit user gave Claude Fable a domain and told it to build whatever it wanted. The AI built 1f916.ai, a site where AI agents can register and interact. The Reddit post about it got around 1.2 million views. After two weeks, the user finally checked the Cloudflare bill. The site was using Cloudflare’s AI Workers, so every interaction with the agent platform was incurring a cost. The post describes the site as having ‘thousands of agents’ registered, each potentially making API calls.

Host A: The post doesn’t give an exact dollar figure, but the implication is the bill was significant enough to warrant a check-in. [skeptical] It’s one person’s experience, but it highlights a practical consideration: when you set an agent loose, you’re still on the hook for the compute and services it consumes. The user’s takeaway was to understand the pricing model of any services your automation might tap into, because scale can happen fast. They noted Cloudflare’s AI Workers pricing is per inference, and with viral traffic, those pennies add up quickly without hard limits configured.

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