Portfolio.

A self-hosted media download and management service — a web app shipped as a single Docker image — that acquires media from more than 1,800 platforms at the best available quality, ad-free, and delivers it properly named and organised into a clean, self-hosted media library.

An automatic quality-selection strategy you can override, processing (clipping, subtitles, format conversion), and whole-playlist synchronisation with resilient state tracking, so a local library stays aligned with its sources over time.

Because it is used at scale by people I have never met, every release carries real constraints: bug reports, edge cases across 1,800+ source platforms, and backwards compatibility. That is the part that does not show up in a side project — and the part that makes it worth citing.

HomeTube's next generation now lives inside Content, as one of its web interfaces. The standalone project remains separate and maintained.

A self-hosted engine that turns a supported source — a URL, a file, plain text — into media, subtitles, transcripts, summaries, translations, chapters, thumbnails, metadata, Markdown and PDF. The public request describes what you want to obtain, never the technical operations to perform.

The backend analyses the source, resolves the capabilities actually available, builds a deterministic execution plan and runs it as an observable job — states, ordered events, progress, logs, provenance, cancellation, resumption — then delivers properly named files into a media library. yt-dlp, ffmpeg, Whisper, the LLMs and the PDF renderer stay replaceable implementation details behind dedicated boundaries.

AI capabilities are optional and local by default: summaries, translations and derived chapters run through a local Ollama, or an explicitly configured Anthropic/OpenAI key; transcription through a local Whisper runner. A missing runner does not make the service unhealthy — the capability is simply declared unavailable, and an impossible request is refused before the job starts.

The interesting problems were architectural: keeping one core usable by a human, by another developer and by an agent, without letting three implementations diverge.

A single entry point: an SSH forced command. Whatever the client sends, the only thing executed is the gateway — no shell, no file transfer, no forwarding possible with those keys.

Behind it, an LLM gatekeeper decides on its own where to look and what leaves. The client never supplies a path; a path that is sent is ignored by design. A routing map shared with clients describes what kind of information lives in each domain — never file names, never amounts, never identifiers.

A written, versioned contract governs the exchange: free-text requests, stable response statuses, a JSON mode, additive writes applied automatically, and mutating or destructive writes gated behind confirmation. Per-client delegated identity — one dedicated SSH key per calling agent — and a timestamped audit log for every request, with duration and return code.

The number that describes the object: 224 lines of code for 582 lines of specification — protocol, client onboarding, gatekeeper rules, routing map. That ratio does not describe a script. It describes a protocol.

It is a personal system, not a product sold or deployed at a third party. Its value is that it runs daily, it is specified, it is audited — and it answers a question the industry is only now starting to formalise, under headings like agent privilege escalation and tool security.

Two physical machines: an Intel NUC as the compact, always-on node, and a custom AMD build with a Radeon RX 7900 XTX (24 GB) on an open frame, for heavy virtualisation and local AI inference. Proxmox is the virtualisation layer; workloads are split between VMs, LXC containers and Docker according to what they need. Systems and volumes are encrypted, with the TPM in the protection chain.

The network is deliberate: a 5G router with its own SIM — chosen so that nothing here depends on a fixed-line ISP — and an architecture designed to work behind CGNAT with no public IP and no port forwarding. Private access over Tailscale and WireGuard, explicit per-service publication through Cloudflare Tunnel, reverse proxies, a personal DNS with recursive resolution. Private by default; exposed one service at a time.

By domain: networking and remote access, reverse proxying and TLS, S3-compatible object storage, a self-hosted Git forge with CI, encrypted and tested backups, monitoring and alerting, automation and orchestration, local GPU inference. Most of the building blocks of an enterprise platform, in miniature and without a safety net.

Local models are served with Ollama on the 24 GB card — a 30 B model quantised to Q4_K_M occupies 18 GB, which leaves about 6 GB for the KV cache and the context window. That is where the quantisation / context-length / latency trade-off stops being theoretical. A local embedding model means the RAG stack depends on no external API at all. Being on AMD rather than NVIDIA is a deliberate difficulty: ROCm and Vulkan instead of the default CUDA path, so the inference stack has to be understood rather than followed.

Coding agents as real working tools on real codebases — exploration, multi-file changes, refactors, test writing, Git, the shell, browser automation, MCP servers, context management and diff review. Claude Code and Codex daily, OpenCode as another agentic environment.

The discipline that goes with it: agents accelerate exploration, implementation and maintenance; they replace neither architecture, nor tests, nor review, nor human responsibility. Final quality is still judged in Git, by the tests, and by how the system behaves in production.

Local and self-hosted inference on my own GPU server, which is what makes the judgement calls concrete — model and quantisation choice, VRAM against latency against quality, serving, and the privacy-first cases where data cannot leave.

Anticipating the failure modes that belong to agents specifically: context drift, loops, wrong tool calls, and costs that run away.