# Watch many SSH sessions at once — a live grid for humans and agents > Source: > Published: 2026-10-06 18:08:47+00:00 *tmux and csshX tile your terminals; Termalin's watch grid tiles every open SSH session as a live view and glows the ones an AI agent is driving.* Anyone who has run more than a couple of servers knows the failure mode: eight terminal windows, a deploy going out across four of them, and no single place to see whether it's working. The old answers — `tmux` panes, `csshX`, a wall of iTerm splits — tile terminals so you can glance across them. They work, and they stop working the moment the thing you're watching isn't just *you*. When an AI agent is driving some of those sessions, "glance across the panes" isn't enough: you need to know *which* sessions are the agent's, and you need to be able to step in. That's what a watch grid is for. `tmux` and `csshX` are about *your* attention across *your* sessions. Broadcast a command to a set of panes, watch the outputs line up, done. It's a genuinely good tool for fan-out work — patch twelve boxes, tail a log on all of them at once. What they don't model is *authorship*. Every pane is you; there's no notion of "this session is being driven by something else, and I'm supervising it." In 2026 that's the gap, because more and more of the sessions on your machine are opened by an agent — [Claude Code](https://termal.in/blog/connect-claude-code-to-your-server-over-ssh/), [Codex](https://termal.in/blog/connect-codex-to-your-server-over-ssh/), [Gemini](https://termal.in/blog/connect-gemini-cli-to-your-server-over-ssh/) — working a host through an [MCP server](https://termal.in/mcp/). A pane full of commands you didn't type needs a different kind of attention than one you did. Termalin's [watch grid](https://termal.in/watch-grid/) is one screen that mirrors **every open session as a live tile**. Not a summary, not a status dot — the actual terminal, updating as output arrives, laid out side by side. Two things make it more than a pretty `tmux`: *Which agents show up here: ones working through Termalin's local MCP server inside the app's own sessions (the "Agent in Terminal" switch). Calls from a hosted chat connector, such as Claude or ChatGPT in the browser, run one by one on the server and land in the audit log instead of a tile.* Because every session stays alive in the background whether or not it's on screen, switching to a tile is instant and nothing is lost when you look away. (Keeping dozens of live SSH sessions responsive at once is its own engineering problem — we wrote up [how the session store stays lock-free under that load](https://termal.in/blog/take-it-out-of-the-map-rust-sessions/).) The live view changes what supervision costs. Without it, letting an agent work a server is an act of faith punctuated by reading a summary afterward — and a summary is [written by the thing you're supervising](https://termal.in/blog/audit-what-an-ai-agent-does-on-your-servers/), so it's the least trustworthy possible record. With a grid where agent sessions glow, oversight is ambient: you see the commands land as they happen, and a steered agent — one talked into something by a poisoned log line or filename — gets caught in the seconds it takes to notice, not in a postmortem. It doesn't lower the odds of a bad instruction; it collapses the time between the instruction and you seeing it. That's the same argument as recording, one step earlier in time. Recording lets you answer "what did it do?" after the fact; the watch grid lets you answer "what is it doing?" right now, and intervene. Together they're the [blast-radius](https://termal.in/blog/agent-ssh-access-blast-radius/) safety net: a [per-host policy](https://termal.in/blog/per-host-command-allowlists-for-ai-agents/) bounds what the agent *can* do, the grid shows you what it *is* doing, and the marked recording proves what it *did*. None of this is agent-only. The grid is also just a good way to run several servers at once: `csshX` workflow with a modern client around it: The difference from stitching this together with `tmux` and SSH config is that it's one app that already knows your hosts, holds your keys safely, and keeps the sessions alive — so the grid is a button, not a shell script you maintain. The watch grid is the *live* layer; it pairs with the durable one. Every session can be recorded **output-only** (never keystrokes), with each agent command marked on the replay timeline, and the audit log keeps the who/when/from-where — the same client-side approach that makes [recording and auditing sessions](https://termal.in/blog/record-audit-ssh-sessions-bastion/) work through a jump host. Watch live to catch things fast; replay and audit to prove what happened. You want both, and they're the same feature seen at two speeds. If your reason for tiling terminals is "I have a lot of servers," `tmux` and `csshX` are fine and free. If some of those sessions are driven by an AI agent — or will be soon — you want a view that marks authorship, lets you take over, and feeds a recording you can trust. That's the watch grid: [see it in motion](https://termal.in/watch-grid/), then [set your agents loose](https://termal.in/ssh-for-ai-agents/) knowing you're watching. *Termalin is a free, cross-platform SSH client with a live watch grid, output-only recording and a built-in MCP server — [download it](https://termal.in/download/), or read how it [keeps keys safe](https://termal.in/security/).*