The argument in one line.
Wrap every agent run in tmux on a VPS so the work survives a closed laptop, a dropped SSH connection, or a dead battery — your local machine becomes a viewport, not a host.
Read if. Skip if.
- A solo founder or indie developer running Codex, Claude Code, or Hermes for multi-hour `/goal` jobs and tired of leaving the laptop open and plugged in all night.
- An AI engineer who has used SSH but never tmux and keeps losing agent sessions every time the connection drops.
- A vibe coder who builds everything locally and wants the cheapest production-grade upgrade to running agents in parallel without a beefier machine.
- Someone evaluating whether a $6–$12/month VPS is enough to host long-running agent workflows instead of paying for a 64 GB MacBook.
- A team lead designing a multi-agent setup where agents need to read each other's terminal panes and share state.
- You already run tmux daily on a remote box and know the difference between sessions, windows, and panes — most of the video is foundational.
- You want a deep comparison between tmux and screen, Zellij, or Byobu — none of those are covered.
- You need Kubernetes, Docker, or container orchestration — this is intentionally a single-VPS, single-user setup.
- You're already comfortable with detached shells via nohup, systemd services, or `&` — the video is aimed at people who haven't internalized persistence yet.
The full version, fast.
Tmux is a terminal multiplexer that splits one terminal into multiple panes and, critically, keeps every session alive after you disconnect. The argument is that long-running AI agents — Codex `/goal`, Claude Code refactors, Hermes runs — need a host that never sleeps, which a laptop can't provide. The fix: rent a $6/month Hostinger VPS, SSH in, install tmux with one apt command, enable mouse mode, then create named sessions where each pane runs a different agent. Detaching with Ctrl-B then D leaves everything running on the server in Lithuania; you can reattach from a phone via Terminus or from any computer via fresh SSH. The video proves the point by killing the SSH mid-build and reconnecting to find a Svelte flight monitor still being built by Codex in YOLO mode. Three commands carry 90% of the value: `tmux new -s <name>`, Ctrl-B then % (or ") to split, Ctrl-B then D to detach.
Chat with this breakdown.
Modern Creator members can chat with any breakdown — ask for the hook, quote a framework, find the exact transcript moment. Unlocks at T2: refer 3 friends + add your own API key.
Create a free account →Where the time goes.

01 · Cold open and what tmux is
Tmux as the substrate for agentic engineering — a terminal multiplexer that keeps sessions alive when you disconnect.

02 · The agentic engineer's setup
All the famous AI developers (Peter Steinberger, Mario Zechner) run tmux on a VPS. Promise: this video will get you there in 20 minutes.

03 · Install tmux locally with brew
The simplest local install on macOS: `brew install tmux`, then check the version. On Windows or Linux, ask ChatGPT or Claude for the equivalent.

04 · First session and the detach magic
`tmux new -s subscribe`, start a `ping google.com`, detach with Ctrl-B then D, do other work, reattach — the ping is still running. The core mental model lands here.

05 · Sessions, windows, panes — and why it works
Three building blocks: sessions wrap windows wrap panes. Tmux persists, spawns, reads, and writes terminal sessions programmatically, which is why multi-agent setups need it.

06 · Get a Hostinger VPS
KVM-2 plan, 24-month billing for the biggest discount, coupon `david` for an extra 10% off. Pick a server location, complete checkout, land in the Hostinger panel.

07 · SSH into the VPS
Copy the SSH command from Hostinger, reset the root password if you lost it, paste, log in. Everything from here runs on the server in Lithuania.

08 · Install tmux on the VPS and enable mouse support
`apt update`, `apt install tmux`, then the non-negotiable `echo set -g mouse on >> ~/.tmux.conf` — without mouse support tmux is unusable for most people.

09 · Splitting panes and running first agents
Start `tmux new -s agents`, run `top`, split with Ctrl-B % and Ctrl-B ". Detach with Ctrl-B D. Kill everything with `tmux kill-server`. Then install Codex CLI from the docs.

10 · Codex /yolo and the /goal feature
Launch `codex --yolo` in multiple panes. Demo `/goal`: build a full-stack Svelte+Vite flight monitor end-to-end. This run is designed to last 5–15 minutes minimum.

11 · Install Claude Code and run mixed agents
One-liner install for Claude Code CLI, authenticate against a Claude subscription, run `/model` to pick Opus. Now multiple Codex and Claude Code agents run side by side.

12 · Multi-agent orchestration in tmux
Multiple Codex YOLO panes building different features, a Claude Code pane acting as the explainer/advisor. Detach and start another session for a 3D web game in parallel.

13 · Why this is non-negotiable
Closed laptop, dead internet, low memory — agents keep running on the VPS. Everyone in 2026 will have to adopt this pattern or fall behind.

14 · Kill the SSH, reconnect, prove the point
Disconnect entirely, open a fresh terminal, SSH back in, run `tmux ls` — sessions are still there. Reattach: the Svelte flight monitor is still being built.

15 · View the running app via SSH tunnel
Run `npm run dev -- --host 0.0.0.0` in the VPS pane, open an SSH tunnel from the MacBook, browse to the IP+port — the flight monitor renders live.

16 · Closing argument and CTA
Tmux + VPS is the future of agent work. Total setup is 40–60 minutes the first time. Hostinger affiliate is the first description link; the free terminal-commands bundle is the second.
Lines worth screenshotting.
- Tmux sessions survive SSH disconnects, so a `/goal` workflow that needs 24 hours can run on a VPS even when your laptop is closed in a bag.
- A $6/month KVM-2 VPS from Hostinger is enough to run multiple Codex and Claude Code agents in parallel — you don't need a $4,000 MacBook to do agentic work.
- Three building blocks define tmux: sessions wrap windows, windows are tabs, panes are split screens inside one window.
- Ctrl-B is the leader key for every tmux shortcut — you press and release it, then press the next key. Trying to chord it is the most common beginner mistake.
- Without mouse support enabled (`set -g mouse on`), you cannot scroll, click, or select inside tmux — most people give up here before they realize the fix is one config line.
- Tmux can persist, spawn, read, and write terminal sessions programmatically — which is what lets multi-agent systems pipe output between panes.
- When you copy text inside a tmux pane, hold Option (Mac) or Shift (Linux) while selecting — otherwise tmux intercepts the selection.
- Codex with the `/goal` flag is designed for hours-long autonomous runs; running it locally means accepting that your laptop has to stay awake the entire time.
- `tmux ls` lists every session by name — if you forget which session your agent is in, this is how you find it.
- `tmux kill-server` is the nuclear option: it terminates every session, every window, every pane in one command.
- Run any installer inside a tmux session, not outside — if the SSH drops during a 10-minute install, the install dies with it.
- Apps like Terminus on iPhone let you reattach to tmux sessions from your phone, which means you can check on an agent run while away from your computer.
- Codex `/goal` can run for 24+ hours pursuing a single end-state — locally that's impractical, on a VPS it's the default mode of operation.
- Hermes, OpenCode, Pyre, and other open-source agents are built by people who all use tmux on a VPS — the pattern is already standard in the agentic-engineering community.
How to make AI agents survive a closed laptop.
The leverage isn't in tmux itself — it's in moving every long-running agent off your laptop and onto a $6 VPS so the work continues whether you're awake, online, or even alive at your desk.
- Rent a Hostinger KVM-2 VPS for $6/month — it's enough RAM to run multiple Codex and Claude Code agents in parallel, and it stays online 24/7 so nothing dies when your laptop sleeps.
- SSH into the VPS, then immediately install tmux with `apt install tmux` and enable mouse support with `echo set -g mouse on >> ~/.tmux.conf` — without mouse mode you can't even scroll, which is what kills most beginners.
- Memorize three commands and you're 90% productive: `tmux new -s <name>` to start a named session, Ctrl-B then % or " to split into panes, Ctrl-B then D to detach without killing anything.
- Run every installer inside tmux, not outside — if the SSH drops during a 10-minute install, the install dies with the connection unless tmux is holding it.
- Launch agents with `codex --yolo` or `claude --dangerously-skip-permissions` in separate panes so they can take actions without per-command confirmation — only safe because the VPS is isolated from your real machine.
- Use Codex `/goal` for hours-long autonomous runs: state the end state (database integrated, deployed to Cloudflare, 20 features with tests) and let it grind for 24 hours while you're at the gym.
- When you finish a work session, type Ctrl-B then D to detach — never `exit` — so every running agent stays alive on the server for your next reattach.
- Reattach from any device: `tmux attach -t <name>` from a fresh laptop SSH, or install Terminus on your iPhone to check on agents from the train.
- Use SSH tunneling (`ssh -L 5173:localhost:5173 root@<ip>`) to view the in-progress web app the agent is building — your browser at localhost:5173 talks to the Vite dev server on the VPS.
- When you copy text from inside tmux, hold Option on Mac (or Shift on Linux) while selecting — otherwise tmux intercepts the selection and the clipboard stays empty.
- Treat `tmux ls` as your dashboard — it's the canonical answer to "which agents am I still running, and what did I name them?"
- Avoid `tmux kill-server` unless you actually want everything gone — it's the equivalent of unplugging a server rack, and there's no undo.
Terms worth knowing.
- Tmux
- A terminal multiplexer that lets one terminal window run multiple shell sessions in panes and windows, with the key property that sessions persist even when you disconnect.
- VPS
- Virtual private server — a slice of a remote machine you rent monthly, accessible over SSH, that stays online 24/7 so anything you run on it survives your local machine sleeping or losing power.
- SSH
- Secure Shell — the protocol you use to log into a remote server's terminal from your own machine. Once connected, every command you type runs on the remote box, not your laptop.
- Session
- In tmux, the outermost workspace — a named container holding any number of windows and panes. You attach to a session by name and detach without killing it.
- Window
- In tmux, a tab inside a session. Each window can be split into multiple panes. Useful for grouping related agents or workflows.
- Pane
- In tmux, a split-screen region inside a window — each pane runs its own shell. You create panes by splitting horizontally (Ctrl-B %) or vertically (Ctrl-B ").
- Detach
- Disconnecting from a tmux session without stopping it. Ctrl-B then D leaves every process running on the server, ready for you to reattach later.
- Reattach
- Reconnecting to a previously detached tmux session via `tmux attach -t <name>`. The shell looks exactly as you left it, with all output and running processes intact.
- /goal
- A Codex CLI mode that runs an autonomous loop pursuing a stated end-state for many hours, useful for whole-feature builds that would otherwise need constant human prompting.
- YOLO mode
- Codex's `--yolo` flag (and Claude Code's `--dangerously-skip-permissions`) that lets the agent run shell commands and edit files without asking permission at each step — only safe inside an isolated VPS sandbox.
- Mouse support
- A tmux setting (`set -g mouse on`) that enables clicking between panes and scrolling inside them with your mouse — off by default, but essentially required for anyone who isn't a keyboard-only Linux purist.
- Codex CLI
- OpenAI's command-line coding agent, accessible after authenticating with a ChatGPT account or API key.
- Claude Code
- Anthropic's CLI coding agent, invoked with `claude` and authenticated against a Claude subscription, console account, or API key.
- Hermes
- An open-source agentic coding system, mentioned as another long-running agent that benefits from a tmux/VPS setup.
- Terminus
- An iOS/iPad SSH client that supports tmux session reattachment from a phone — referenced as the canonical way to check on a running agent when you're away from your computer.
Things they pointed at.
Lines you could clip.
“Tmux is the one tool that every single agentic engineer needs.”
“Most vibe coders develop all their apps locally on their laptop. Agentic engineers use tmux on a VPS to run multiple agents for hours, sometimes days.”
“If my Internet gets disconnected, my agents keep running. If my laptop runs out of memory, my agents keep running. If I need to close my laptop, the agents keep running.”
“Tmux on a VPS is non-negotiable. I'm certain of it. Everybody in 2026 will have to adopt this or just not be as effective.”
“This is the beauty of tmux — persistence and the multi-agent. Really, it's essential.”
“Even if my MacBook literally gets shredded to pieces, even if it explodes, it will still keep running.”
“This is the future. Running tmux on a VPS, you SSH into it.”
“Most vibe coders are completely scared of tmux. They don't know what it does. They don't know how to set it up. They don't have a VPS.”
Word for word.
The bait, then the rug-pull.
David Ondrej opens cold: "Tmux is the one tool that every single agentic engineer needs." By the four-minute mark he's split a single terminal into a dozen panes, each one ready to host its own Codex or Claude Code agent. The hidden promise is bigger than tmux itself — it's that you can rent a $6/month VPS and let a Svelte app build itself overnight while your laptop sleeps in another room.
Named ideas worth stealing.
The three tmux building blocks
- Session — the named workspace that wraps everything; you attach to it by name
- Window — like a tab in a browser; one session can hold many windows
- Pane — split-screen region inside a window; each pane runs its own shell
The mental model you need before any of the keyboard shortcuts make sense.
The minimum tmux keymap to be productive
- tmux new -s <name> — create a new named session
- Ctrl-B then D — detach without killing anything
- tmux attach -t <name> — reattach to a session by name
- tmux ls — list every active session
- Ctrl-B then % — split pane horizontally (left/right)
- Ctrl-B then " — split pane vertically (top/bottom)
- tmux kill-server — nuke every session
Seven commands cover 90% of daily tmux use.
The agentic engineer's host stack
- VPS — $6/month Hostinger KVM-2, Ubuntu 24.04, always-on
- SSH — the access protocol from your local machine
- Tmux — persistent multiplexer wrapping every agent run
- Codex CLI / Claude Code / Hermes — the agents themselves, one per pane
- Terminus on iPhone — reattach from anywhere, even without a laptop
The five-layer stack that lets a single operator run multiple long-running agents without keeping a laptop awake.
Why tmux is the substrate, not the surface
Tmux exposes a programmatic API to persist, spawn, read, and write terminal sessions. That's what lets one agent read another agent's pane output — without it, multi-agent setups can't share state through the shell.
How they asked for the click.
“If you don't have your own VPS, use the first link below the video. Get your VPS today because it's essential. All of the resources, terminal commands, everything I showed from the video is bundled below — the second link in the description, completely free.”
Two-tier CTA. The hard pitch is the Hostinger affiliate (first link) with coupon DAVID. The soft pitch is a free terminal-commands bundle gated behind an email opt-in (second link). The affiliate revenue covers the production cost; the email list compounds the audience.
































































