Tutorials
Every free guide, grouped by series. Type a keyword to filter.
Start here
- ManifestoWhy run your own AI: control, portability, and honesty about the limits.
- Support the project: donations and sponsorshipEvery tutorial here is free, open and measured on real machines. Hardware, electricity and long nights are not. A recurring donation through Liberapay, or a sponsorship for companies, keeps the tutorials coming.
- FAQ: the questions everyone asks firstDo I need a big graphics card? Is it really free? Is my data safe? Where do I start? Short, honest answers, each with the tutorial that goes further.
- Before you start: hardware, honestlyWhat fits on which card, with measured numbers, and what to buy first.
- Glossary: the words of this site, in plain languageVRAM, container, proxy, DNS, port, token… every technical word used in the tutorials, explained in one or two sentences.
- Inspirations: the projects and people we learn fromNothing here was invented alone. The open-source projects we build on, the authors whose work made us ask better questions, and what each one taught us.
- Our findings: every tip and measured fact, one line eachSince the first day, every discovery, every trap and every benchmark result we paid for, in one page. Each line is a fact measured on our machines, with the tutorial that explains it.
- The workshop: every tool behind this site, one line eachAbout forty repositories built and run here, grouped by job, each in one sentence, with the tutorial that explains it. Open-source licences; the method in each one is yours to copy.
- About: who writes this, on what machines, and how we measureThe real homelab behind the tutorials, how we measure, and what we do not promise.
Local AI
- Install the NVIDIA driver and check your cardThe one dependency everything else stands on, and how to know it really works.
- Docker with access to your GPUInstall Docker and the NVIDIA Container Toolkit, test it, and avoid the trap after a driver update.
- Your first local model with llama.cppDownload an open model, serve it on your GPU, talk to it with the same API as the big clouds.
- Free your graphics cards for AI, and still playPut the desktop on the integrated GPU, give every byte of VRAM to the models, and let Steam borrow a card only while you play.
- A gaming PC that became an AI server, and still playsNo screen on the tower: a virtual display, game streaming encoded by the integrated GPU, and an Android handheld as the console.
- Sleep when idle, wake on demand: the energy recipeA tower with big graphics cards should not run for nothing. A small always-on machine wakes it in seconds, from anywhere, without opening anything to the internet.
- Giving code work to a local agent without it breaking everythingLocal models write plausible code that does not run. The rules we measured: four deliverables at most, the real data, a test that executes, and a pull request someone reads.
- One gateway for all your models, and three ways a local model freezes your agentsOne address for every client, model names that never lie, and the three settings that froze our agents for days.
- Free cloud models behind your gateway, and routes that say who answersWhen the cards are busy or off, eight official free tiers can take over: Groq, Cerebras, Google AI Studio, Cloudflare, OpenRouter, Cohere, NVIDIA and Mistral. How to wire them into the gateway without one key in a file, how to group them into routes named auto-… that fall back in order, how we proved the fallback, and the traps that cost us an evening.
- Several models, two graphics cards: a grid instead of a juggling actOne container per model and per card, swaps that cost half a second per gigabyte, a voice service that gives way, and why a model must never fill its card.
- RAM, zram and swap on an AI machine: the three thieves that cost us a factor of tenBefore suspecting the GPU, measure the RAM. Three settings were eating it; fixing them took a model from 1.9 to about 20 tokens per second.
- A second graphics card through OCuLink: more VRAM without a new motherboardWhen the motherboard has one big slot, an M.2 slot can lend its four lanes to an external card. What worked, what did not, and how to read the link.
- Speculative decoding (MTP): up to twice as fast on the same cardA small head guesses the next tokens, the model checks them in one pass. The right flags, the value to measure yourself, the real gain in production, and the crash to watch for.
- A tiny local judge for the small decisionsYes or no, which of these, how much: a sub-1B model on the processor answers typed questions in 0.05 s with an honest confidence. And why the code, not the prompt, must send it the question.
- A RAG on your own journal: never solve the same problem twiceWrite down what you solved, let a search service index it, and let your agents ask it before they guess. The chunk size that matters, and the three ways it silently serves stale answers.
- Does your test catch anything? Prove it by breaking the code (mutation testing)A green test only says it found nothing, which is also what a broken test does. Inject defects one by one and check that each one turns a test red.
- One browser per agent: web automation that does not trip over itselfTwenty agents in one browser looked efficient and produced false results. Separate browsers, clean profiles and encrypted DNS fixed it; here is the setup and the limit of a laptop.
- A 177-billion-parameter model on two consumer cards: placement beats bandwidthA mixture-of-experts model that does not fit in VRAM can still run at home. Where its weights live matters more than the PCIe link, and two settings decide between a fast server and a frozen machine.
- Hybrid: local first, the cloud only when it is worth itA queue that sends each task to the cheapest agent able to do it: local models, then a cheaper hosted agent, then a frontier one. Daily caps, sandboxes, and your confirmation before anything climbs.
- Slow for no reason? It is re-reading: the KV cache trapA local model that generates fast but takes ten minutes to answer is not slow: it is reading the prompt badly. One flag made it 21 times slower, silently. How to measure it in two minutes, and the two settings to use instead.
- Your GPU container runs on the CPU: three traps after an update or a rebootThe model says healthy in seven seconds, then crawls: it is running on the processor. The card is visible, CUDA is not. A stale device description, a device number that changes at every boot, and the bisection that found them.
- Your non-Steam PC games on Linux: Lutris and Ubisoft ConnectSteam is not the only shop. Lutris installs the Ubisoft, EA, GOG and Epic launchers inside Proton, on the disk of your choice, and they run like on Windows. Ours holds Assassin's Creed Valhalla, Immortals Fenyx Rising and Star Wars Outlaws, ready to play from the sofa.
- Long context on a 16 GB card: KVMem, and the build we runAgents read long conversations. KVMem keeps the whole history in system RAM and only the relevant blocks on the card: 48 out of 48 recall checks, flat speed past 100k tokens, 4.9 GB of VRAM saved. And what our build adds: one binary for two card generations, experts in host memory, token probabilities, a GPU expert cache that runs a 177B model from a single card.
- The lab notebook: what we tried on the infrastructure, what we keptEvery experiment on our machines, with its verdict and the number that decided it. Kept, rejected, paused. The fastest way to know what is worth an evening before you spend yours.
- Which local model for which job: a bench that measures real workBenchmarks favour the fast model; real work favoured the reliable one. A bench where code judges every answer, then each model works for real on a small repository. What it showed: small and well-framed beats big and vague, and four settings matter more than the model.
- A fully local judge in two passes: Tev1 first, Nimble when in doubtA 0.8B model answers in a twentieth of a second; a 9B one is slower but surer. Code sends every question to the small one, keeps its answer when it is confident, and only wakes the large one for the rest. On real e-mails, the pair matches the hosted judge, with nothing leaving the house.
- Strata: a 177-billion-parameter model on one gaming cardStrata is an open-source engine built to run Qwen3.8-Flash-Next on an ordinary PC: one 12 to 16 GB card and enough RAM for the experts. How we plugged it into our GPU grid as one more slot, and the three details that decide whether it starts.
- Your graphics card at x4 instead of x16: diagnose it, and get the x16 backA card can silently run on a quarter of its lanes after a reboot. How to read the link the firmware really gave it, why the BIOS has no 'x16' setting to pick, the one wrong fix to avoid, and what a power cycle did for us: from x4 back to x16, with nothing changed.
- Stacking free tiers: the quota wardenEight providers each give away a small daily quota. Taken one at a time, that is not a workday. Added up, routed and watched automatically, it is: how a bit of automation, thread teleportation and provider handoff keep a swarm moving between frontier quota cycles.
- turnstile: one model per card, and a service that never lies about what's runningSeveral local models, one or two GPUs: config files drift and end up describing a machine that doesn't exist. turnstile stops believing files and observes the machine: one slot at a time per card, a clean queue, five facts verified every ten seconds.
Local agentic automation with n8n
- n8n against Zapier, Make, IFTTT and Power Automate: why self-host your automationsThe hosted services bill every step and carry your data through their cloud. Self-hosted n8n runs at home, calls your local models, and costs nothing per run. And when the SaaS is still the better choice.
- n8n: an agentic clock that notices what stoppedEvery job declares its cadence; a tick compares each one's last sign of life every minute; a watchdog outside n8n watches the tick itself. How an agent network learns that something went silent.
- n8n: route, repair and generate workflows, with guardrailsA request in plain words that loads the right model; a workflow that reloads what crashed, within strict limits; and workflows written by code, versioned like the rest.
Your agent stack
- One client, your whole lab: the tourFrom a single app on your phone or desktop: coding agents on every machine, images and video on your cards, the guard machine's alerts, your workflows and your house. The concept sounds big. Each brick is small, readable, and already running here.
- What an agent harness is, and how to choose yoursThe model writes text; the harness turns it into work: it reads files, runs commands, asks permission, manages the context, and decides when to stop. Six harnesses run here, each for a reason. What sets them apart, and five questions to pick the right one for each job.
- FH Coder: a local coding agent that works while you sleep, and never merges unreadDrop an intention, get a tested pull request. FH Coder is our production chain for local models: a shared queue, a runner in a separate account, a verification gate that fixes the style by itself, a report that opens the pull request and feeds the knowledge base. Plus the fh-coder agent that brings the same doctrine into OpenFox. How it is wired, and how to set it up.
- OpenFox: the coding agent that takes local models seriouslyMost coding agents are built for a frontier model and tolerate a local one. OpenFox is built the other way round: a plan becomes an immutable contract of acceptance criteria, the agent loops until every criterion passes, and you see the prefill and generation speed of your own card live. Open source, free per token, and our agent of every day.
- Claude Code, two ways: on the subscription and on your own modelsThe same agent in two roles: the operations agent on the subscription, with rules and hooks that refuse dangerous commands, and an isolated junior on local models through three environment variables.
- Kimi Code: the long tasks, on a server, from anywhereA second hosted agent with a one-million-token context, kept running on the server in a terminal multiplexer and reached from laptop or phone. Plus the two traps that cost us an evening: the tool-list size limit and a resume tied to the folder.
- Kimi K3.1 Pro is out: what changes, what it costs, how to try itMoonshot AI releases Kimi K3.1 Pro, the first model of its K3.1 series: K3 post-trained with far more compute, a one-million-token context, open weights announced before 4 November. What is announced, who measured what, what it costs on the API and in the Kimi Code subscription, and a referral link to start with a bonus.
- Inari: your agents in your pocketThe laptop sleeps, the phone does not. A native Android console that follows coding sessions live, talks to a local orchestrator, and holds the one decision that stays human: the go on a task. Built without Google, published without a store.
- Rooms and FoxDesk: one conversation, any machine, any agentA rooms controller keeps every agent conversation durable and replayable, across several machines. An open-source agent core, never patched, with your agents plugged in by adapters. And a desktop client served on every workstation, so one machine down never cuts you off.
- BMAD with small models: the model proposes, code decidesA planning method for agent work, adapted to local models: stories with a schema, scenarios written as data and run by pytest, one story alive at a time, and no model ever delivering a verdict.
- Reverse engineering with evidence: let the agent prove, not guessBefore wiring your stack into someone else's program, understand it with proof. An open-source reverse-engineering toolkit that agents can call: analyze once, keep a snapshot, ask follow-up questions, and get answers with their evidence and their limits.
- The context floor: where an agent's tokens really goWe measured an agent run token by token. The conversation was 1 % of the bill; the rest was the same 30,939 tokens of instructions and tool descriptions, sent again at every turn. How to measure your own floor, and which levers actually move it.
- Let an agent see and drive your desktop, under your eyesSome tasks have no command line: a settings page, a checkbox, a form. An agent that takes screenshots and moves the mouse can do them while you watch. Two open-source tool servers, four constants that make it work, and a referee that says whether a click actually did something.
- Skills: teach your agent a procedure onceA skill is a folder with one Markdown file: when to use it, and how. The agent loads it only when the task calls for it, so a hundred skills cost nothing until needed. The ones we use every day, from shaping answers for an ADHD reader to a full security review, and how to write your own.
- Why is it failing? Give the model facts, and a machine that remembersAsked why something fails, a local model explores blindly and invents files. Handed the facts, the same model answers right: 5/5 in 72 seconds instead of 2.75/5 in 9 minutes. Two small tools: one that gathers the facts, one that records what the machine was living through.
- The account that reasons holds no secret: agents and authorityAgents deploy, push and create repositories here, yet none of them holds a token or a password. The rule that makes it safe, and three small services built on it: a deploy daemon with a closed list, a forge helper behind a socket, and a repository bootstrapper that never lets a repository live without its guard.
- Knowledge packs: facts with a source, a test and an expiry dateModels answer from memory, and memory goes stale. A knowledge pack is a small unit of verified knowledge served to agents: each claim has a dated source, each procedure an executable assertion, and each fact an expiry date that opens an issue when it passes.
- A workstation assistant that points, never typesSay a sentence, a small local model picks one function from a closed table, and the script runs it. Questions are answered from your own notes first, then by a cascade of models that must say 'insufficient' when they do not know. What the measurements imposed, one rule at a time.
- billion-context: a context-compression proxy, measured honestlyA local proxy that sits between your coding agent and its model and promises to stretch the context. We installed it carefully, plugged it into Claude Code, Kimi Code and OpenFox, and measured. Below 100k tokens it saved nothing, and once it cost three times more. When it might help, and how to try it without risk.
- From an e-mail to a pull request: the go labelSend yourself an e-mail with an idea; it becomes a drafted issue waiting for you. Put one label on it, and an agent picks it up, works, opens a pull request, and closes the issue when it is merged. One rule keeps it safe: no code ever adds the label.
- Route requests with a small trained classifier, not keywordsWhich model should take this request: the small, the default, the big one? Keywords got it right 63.7 % of the time, less than always answering 'default' (72.6 %). A small classifier trained on 237 real requests reached 84.0 %, in 20 milliseconds, without a graphics card. And the bigger lesson it revealed: the tool catalogue.
- The deterministic doctrine: the model proposes, the code decidesThe one idea running through every layer of this stack: let models do what has many right answers, and give everything with one right answer to plain code. Why it makes small local models reliable, why a good tool is often worth more than a skill, and the numbers that convinced us, layer by layer.
- fh-tools: fourteen deterministic tools for coding agentsEach one answers one question with a fact, always the same way: does this patch apply, which added lines does no test exercise, does this text carry a credential, have we seen this failure before. JSON in, JSON out, exit codes that mean something, and a checker that replays every case three times.
- The fh- suite: sixty small commands that run the labEvery everyday gesture here is a short command named fh-something: ask the fleet, hand work to an agent, follow it live, deploy, check health, find why something fails, publish a branch. Grouped by job, one line each, with the rule they all share.
- An agent's state as a portable file: moving a running agent between machinesKeep an agent's whole state in a folder of plain files, switch its model mid-conversation, and move it from one machine to another without ever running it twice. The design, the one ambiguous moment in the protocol, and how to test it with injected failures.
- Inari: Claude Code, Codex and Pi, self-hosted under your own nameCloudroom's desktop app is Apache-2.0 and its core needs no account — self-host it, and a small MIT tool repaints the identity so it is yours: logo, colours, product name. The upstream engine is never forked, only patched in place at build time.
- Inari is now MIT, and it runs on a core of our ownInari began as a coat of paint on Cloudroom, an excellent app for Claude Code, Codex and Pi. It is now its own core, interface and Android client, MIT-licensed. What we borrowed, why it is great, and why ours answers our needs better.
Create with local AI
- Create with local AI: every tool of the studioImages, video shots, whole short films, music, songs, 3D objects, diagrams, animated explainers: everything we create here runs on our own cards or in plain code. The map of the studio, what each tool is good at, and where to start.
- Vibe coding and digital art: when describing becomes makingSay what you want, let a model write the code, judge by what appears on screen. Vibe coding was born as a joke about programming; in digital art it is a real shift. Generative visuals, shaders, live-coded music, motion design as code, all reachable by description, with a local model. What it opens, what it costs, and where we draw the line.
- ComfyUI: images, video and 3D on your own cardsThe node editor for generative models, run as a service that only listens on the machine itself, one instance per card. Which model for what, how long a five-second video shot really takes, and how to drive it from scripts and agents.
- A local music studio that keeps the project: fh-seqOnline song generators hand you an opaque MP3. fh-seq keeps the song as a project: sections and lyrics, a tree of renders where every retouch keeps its parent, repaint of a time range, stems you can mix, a clip shot by shot. All on open-source engines, on your own cards.
- ACE-Step: three minutes of music in 27 seconds, on your own cardAn open-source music model fast enough to be a tool: whole tracks from a few style tags, repaint of a passage, variations. How we use it for an ambience bank, a soundtrack for automatic videos, and why it never runs while the music plays.
- A sentence becomes a film: the local production chainOne sentence in, a short film out: a local model writes the technical sheet, code refuses what would waste a render, the cards render the shots, add synchronised foley and music, cut and edit. Measured step by step, with the three decisions that make it work.
- ArtCraft: stage the scene before you generate itPrompting is guessing; ArtCraft lets you build the shot: layers in 2D, sets and props in 3D, posed characters, a camera you place, then the generation. An open-source creative studio we build from source on Linux, with the one dependency fix it needed.
- Diagrams in code: every figure of this site is a small functionNo drawing tool, no image file, no library: each diagram here is a Python function that writes SVG, with its labels in two languages and a caption that screen readers read. A test checks every one is drawn and described. And when you need a richer chart, a diagram skill with forty-five types.
Your Linux workstation
- Undo any change: snapshots of your home folder with snapperInstead of .bak copies everywhere, a photo of your folder before every risky change, taken in a second, and a one-line undo.
- A breach warning: changing dozens of passwords without locking yourself outThe order that never leaves you outside, how to choose what to change first, and why an outdated vault entry is worse than an empty one.
- A second-hand laptop as a comfortable Linux workstation (Omarchy)Check what you buy, install a ready-to-work Linux desktop, and the three surprises that look like bugs but are not.
- Rebuild your machines in one command, and know what you changed by hand (Ansible)Describe each machine in a repository; --check --diff tells you what drifted, without touching anything. A first playbook, and the beginner traps.
- Secrets that never touch a file: passwords for scripts and agentsA vault for people's passwords, a secrets manager for machines, and one rule: a secret goes from the vault to its program through a pipe, never through a file, a command line or a screen.
- Your own Android app, outside the Play Store, with its own updatesBuild in a container, sign properly, serve updates from your own server. And the rule that silently breaks updates if you forget it: a version number is used once.
- One fingerprint for the whole lab: sudo on the server, your vault on the laptopThe laptop's fingerprint reader approves a sudo on another machine, and unlocks your password manager. A signed answer, a fresh random number per request, the private key never leaves the laptop, and the password always remains as a fallback.
- SSH for an agent workstation: instant, safe, and four trapsWhen agents run hundreds of SSH commands a day, the details matter. Shared connections that drop each call from 300 ms to 12, free text that must never travel in a command line, the right way to open a window on another machine, and the kill that takes your own shell with it.
- Purrd: music while the agent works, silence when it is doneStop staring at a terminal. A small open-source program plays generated lo-fi music while a long task runs; the return of silence tells you it finished. It wraps any command, follows Claude Code through hooks, and can speak a line when the agent needs you.
- Inframagotchi: a cat whose health is your homelab'sMonitoring you actually look at. A manga stray cat lives in a window on your desktop: bright-eyed when everything runs, sweating, bandaged, then knocked out as services fail. Real probes underneath, a drawing that only knows one number, all drawn in code.
- Three small tools for your workstation: your AI history, a context meter, a fleet inventoryTake your Claude.ai conversations home as readable files, see how full your local agent's context is right in the status bar, and know what changed on each of your machines since last week. Each one is a single script with no dependency.
- Omarchy in depth: extend it without breaking updates, and five 'bugs' that are notOmarchy turns Arch and Hyprland into a ready workstation. Extending its menu the supported way, and five strange behaviours we met, each with its real cause: a screen dark at '100 %', a bar that vanishes for good, four kinds of title bars, milky transparency, a menu entry that cannot be pressed.
- Take your Claude.ai history home: claude-archive, step by stepYour conversations with Claude.ai, as files on your disk: one Markdown file per conversation, every code block as a real file, a checklist of attachments to fetch by hand, and a manifest that proves nothing was lost. One script, no dependency, no network.
Homelab: replace the subscriptions
- Homelab 1: Proxmox, the base under every serviceOne machine, many isolated servers, snapshots and backups. The foundation of the series that replaces Google and subscriptions.
- Homelab 2: one HTTPS entrance for all your servicesA reverse proxy with free certificates: how this very site went online, in fifteen minutes.
- Homelab 3: your own password manager with VaultwardenReplace the password manager you rent. The server never sees your passwords, and the backup that actually restores.
- Homelab 4: block ads and trackers for the whole house with AdGuard HomeOne DNS server for every device, phones and TVs included. And the local rewrite that keeps your own services at home.
- Homelab 5: backups that survive an attack on your serverTwo copies, two machines, and the detail that matters most: the second copy is pulled with a read-only key, never pushed.
- Homelab 6: reach home from anywhere without opening a portOnly the public sites go through the box. Administration, models and private services go through an encrypted private network.
- Homelab 7: replace Google Photos with ImmichAutomatic phone backup, faces, maps and search, at home. And the two things you must back up, not one.
- Homelab 8: your own code forge, where nothing reaches main without a green checkForgejo with its CI, a protected branch, and the rules that let AI agents propose code without ever breaking main.
- Homelab 9: your own search engine, for you and your agentsSearXNG asks dozens of engines for you, without an account or a profile. And it gives your local agents a web search they can read.
- Homelab 10: notifications from your servers and agents, on your phonentfy turns one curl line into a phone notification: backups, agents waiting for you, a failed job. Self-hosted, with accounts.
- Homelab 11: your files and office suite instead of Google Drive and DocsNextcloud for files, calendars and contacts, OnlyOffice to edit documents in the browser. The three-party mechanism that explains every setup error.
- Homelab 12: every paper you own, scanned, read and searchable with Paperless-ngxDrop a scan or a photo in a folder; it is read, tagged and filed. Search a word on any invoice of the last ten years.
- Homelab 13: a task list for you and your agents with VikunjaReplace Todoist or Microsoft To Do, import your lists, and give your agents a shared queue where the decisions only you can take wait for you.
- Homelab 14: automate without a Zapier subscription, with n8n and a decision cascadeWorkflows that connect your services, and the pattern that keeps them cheap and private: rules first, a small local judge, a hosted model only for public data, you for the rest.
- Homelab 15: Home Assistant with a local voice, in FrenchSpeak to your house without any cloud: speech recognition and synthesis on your own GPU, a CPU fallback when the card is busy, and a local model to understand.
- Homelab 16: keep everything you read, forever, with KarakeepReplace Pocket and browser bookmarks: full-page archives that survive the original site, tags and summaries by a local model, and your agents can search them.
- Homelab 17: your errors find you, with GlitchTip instead of SentryA self-hosted error tracker in three containers, compatible with Sentry's SDKs: every crash of every service lands in one place, grouped and dated.
- Homelab 18: ban the scanners with fail2ban, and the Docker trap that makes bans uselessRead the proxy's logs, ban an address after a few errors, and make sure the ban sits where the traffic really passes.
- Failures that call you: every service reports, every deploy can roll backA service that fails in silence is found days later. Three small systemd habits make every failure call you, without a monitoring suite: a failure template, a daily health ping that tolerates a sleeping laptop, and a delivery script that puts the old version back by itself.
- One table for everything that happens: fleet eventsPushes on the forge, failed services, nightly security scans, deliveries, agent runs: everything writes one line to the same database table, with roles that can only insert or only read. Then a dashboard, alerts and agents all read the same facts.
- Homelab: a private ChatGPT, every PDF tool, and transcription at homeThree self-hosted services: Open WebUI to chat with your own models, Stirling-PDF to merge, split, sign and OCR documents, Scriberr to turn recordings into text. Each replaces a subscription or an upload to a stranger's server, and each needs the same three safety settings, learned the hard way.
- Before you open a website to the internet: a security audit in ten checksWe audited a self-hosted site before trusting it, without attacking anything: headers, encryption, DNS, the neighbours that share its door, the tools that are supposed to defend it. The site was clean; what sat next to it was not, and the ban tool had never banned anyone. The method, the commands, and the fix for each finding.
- Resisting DDoS when your site lives at homeNo setting on a home server can stop a flood that saturates the line. What you can do: make small attacks useless at the proxy, serve the site from memory, and, for real protection, put a cheap rented front with anti-DDoS in front of the house, so its address is never published. Four layers, from free to five euros a month.
- Your own CI on Forgejo: the runner traps, one image for everything, and tests that cannot lieA self-hosted forge with its own CI runner is freedom, until a job waits forever without a word. The traps of Forgejo Actions, a single runner image that removes the tools a job reinstalled at every run, a language ratchet, and the rule that saved us the most time: read the forge's log before reproducing anything.
- ntfy everywhere: the voice of the whole labOne small self-hosted notification server, and every part of the lab can reach your phone: failed services, an agent waiting for your approval, a new message on the contact form. How we use topics, priorities and links that open the exact screen you need, without Google.
- Tailscale as the backbone: everything private, reachable from anywhereThe model gateway, the phone console's API, the fingerprint relay, game streaming, the health reports of a laptop on the road: all of it travels over a private network, none of it is on the internet. How we publish a service to the private network only, with real HTTPS, and the defaults worth tightening.
- fh-probes: measure a node without becoming the cause of what you measureGPU, RAM, memory pressure, model servers: one JSON line per second, read straight from NVML and /proc, without a single subprocess. And fh-history, which lays your runs over the same timeline: "this run failed" becomes "this run failed while memory pressure climbed to 91".
- A service burns a core and gets killed: find out why in ten minutesA self-hosted app pinned a CPU core and was ended by the out-of-memory killer several times a day. A ten-second profile of the live Node process named the exact loop, and the same session exposed a second, unrelated memory thief: hypervisor ballooning.