Running a Containerized ttyd and tmux Web Terminal over Tailscale for Mobile Homelab Access

A phone showing a tmux session in a browser terminal served by a Docker container over a private Tailscale network

A phone can reach your homelab terminal without a single public port, and it can come back to the same shell after a dropped signal. The recipe is a small Docker container running ttyd, a web terminal daemon, wrapped around a persistent tmux session, reachable only over your private Tailscale network. If a long build or an AI coding session is running when you lock the screen, it keeps running, and you reattach when you are ready.

This guide builds that container from scratch. For the personal story behind why I wanted it, read Running Full AI Coding Sessions from My Phone with ttyd, tmux, and Tailscale on Frizzle Tech Blog.

Setting Up a Paperclip Multi-Agent Organization to Write and Review Code

Self-hosted Paperclip multi-agent control plane and PostgreSQL 17 orchestration stack running in Docker

Over the past four tutorials we built our local GPU inference layer with Ollama and vLLM, stood up a Proxmox VE cluster, and deployed Hermes Agent; today we are setting up Paperclip (ghcr.io/paperclipai/paperclip:latest) with PostgreSQL 17 in Docker Compose to coordinate a multi-agent organization that writes, reviews, and ships code and documentation across isolated workspaces.

Running a single coding agent in a chat window works fine for one-off scripts, but larger projects quickly suffer from context bloat and self-grading bias: the same agent that wrote a bug is rarely the best critic to catch it. Paperclip lets you define a persistent organization of specialized agents (such as a Lead Architect, an Implementation Engineer, and an independent QA Reviewer) backed by a shared issue tracker, explicit role prompts, and budget guardrails.

Setting Up Hermes Agent Locally with a LiteLLM Router and Free Cloud Fallbacks

Autonomous Hermes Agent container paired with a LiteLLM routing switchboard across local GPUs and cloud fallback models

Earlier this week we set up local Ollama and vLLM inference servers; today we are deploying the NousResearch Hermes Agent container (nousresearch/hermes-agent:latest) paired with a LiteLLM router so our autonomous agent can execute cron jobs, maintain a Markdown knowledge vault, and fail over gracefully between local GPUs and cloud APIs.

Running an always-on agent against a local Git-backed Markdown vault introduces two classic operational traps: model endpoint timeouts when your local GPU is busy, and PermissionError crashes when a container writes root-owned files into a volume shared with your host user. We will solve both in a single Compose stack.

Setting Up Intelliprompter with TypeSafe Jev for Real-Time Speech Scoring

Self-hosted Intelliprompter presentation teleprompter container using TypeSafe Jev to score live speech against talking points

After watching NetworkChuck's video on TypeSafe Jev and exploring the official TypeSafe Intelliprompter cookbook, I paired up with OpenAI Codex across two sessions (Part 1 build session and Part 2 multi-user and security session) to turn the single-user cookbook reference into a multi-user, self-hosted container. In this guide, we will start with the exact prompt used to have Codex generate the application from the TypeSafe cookbook and pull its API key from the system keyring, and then deploy the resulting Intelliprompter stack in Docker Compose so TypeSafe Jev (jev-1.13.0 / jev-latest) can evaluate live speech and advance presentation topics automatically.

Traditional teleprompters force you to read a scrolling wall of text word for word, which immediately makes a technical talk or video recording sound robotic. Intelliprompter flips that model on its head: you organize a speech into sequential topics and bulleted talking points, speak naturally in your own words, and let browser speech recognition stream your transcript to TypeSafe Jev. Every few seconds, Jev scores how thoroughly you covered each remaining point on a 1 to 5 scale; as soon as a talking point crosses your configured threshold (default 2.5), Intelliprompter locks that point as complete and automatically advances the presentation overlay to the next topic once the current topic is finished.

Setting Up vLLM for High-Throughput OpenAI-Compatible Serving

High-throughput continuous batching and PagedAttention KV-cache serving with vLLM in Docker

After standing up Ollama for quick model switching, today we are deploying vLLM (vllm/vllm-openai:latest) in Docker on port 8000 to serve a dedicated OpenAI-compatible API built for concurrent multi-agent workloads.

Ollama is tough to beat when you want to swap models on the fly, but as soon as you have three or four autonomous agents firing parallel tool-calling prompts at the same time, request queuing starts to hurt. vLLM uses PagedAttention and continuous batching to process concurrent requests simultaneously in GPU memory, turning a single homelab GPU into a genuine multi-tenant inference server.

Setting Up Ollama for Local Homelab AI Inference

Running dual isolated Ollama containers on a single homelab GPU host so background jobs never evict your active coding model

In this guide, we are setting up Ollama in Docker on a local Linux GPU server, with a practical twist I learned the hard way: running two isolated container instances side by side so scheduled background agents do not constantly evict the model you are actively using in your IDE.

When you run a single Ollama container on port 11434 and point your coding assistant, your home automation scripts, and your cron jobs at the same endpoint, the first background job that requests a different model weight will unload your active coding model from VRAM. Splitting your deployment into a primary ollama-hub container on port 11434 and a secondary ollama-worker container on port 11435 gives you clean workload isolation while keeping everything reproducible in a single Compose file.