the agent OS war is being won in tmux, not in chat

the stack everyone is quietly standardizing on

spend a weekend reading how people actually run agents in production and a pattern shows up that nobody is marketing. the agent doesn't live in a chat window. it lives in a tmux session, on a tailscale mesh, accessed through a remote terminal client. persistent terminal, network mesh, secure remote auth. three primitives, repeated across every serious local-agent setup we've watched ship in the last quarter.

that is not a UX preference. it is the architecture leaking. agents that do real work need state that survives a disconnect, a network surface that crosses devices without re-auth, and a credential plane that doesn't re-prompt every tool call. chat UIs cannot hold any of those. the moment an agent has to run for six hours, hand off to a CI job, and come back with artifacts, the chat box becomes a viewport, not a runtime.

the dynamic: the runtime moved, the discourse didn't

call it the runtime migration. the consensus read of the agent war is still consumer-shaped: chatgpt vs claude.ai vs gemini vs perplexity, fighting over a text box. that frame is a year out of date. the operational layer where agents actually execute has migrated to dev environments, and the dev environment is a surface microsoft already owns end to end via github, vs code, and codespaces.

this is the part the chat-UI scoreboard misses. cursor's agent mode, replit's agents, codespaces, and the local tmux-tailscale-termius stack are not separate categories. they are the same architecture at different points on the hosted-to-local spectrum. all four extend the same three primitives. whoever is closest to those primitives by default wins the distribution game without having to ship a single new consumer product.

receipts

the cadence data backs the migration. anthropic shipped claude code and has been compressing release intervals; openai bought a browser team and has been pushing codex-style flows; google deepmind and qwen are in the same compressing-cadence cluster. the labs whose cadence is flattening are the ones without a deployed runtime surface, which is why meta's llama line looks structurally different from the rest. release velocity is a proxy for live data loop, and the live data loop now includes terminal sessions and CI runs, not just chat turns.

on the pricing side, github copilot's bundling into vs code and github is the only thing keeping a default surface closed against the open primitives. cursor's standalone position is genuinely good product, but it is renting distribution on the same editor fork microsoft maintains. replit and codespaces are converging features. and tailscale, the connective tissue half of the local stack, was acquired into the same orbit of dev infra that microsoft, github, and the hyperscalers are quietly consolidating. the operator who owns the editor, the repo, the runner, and increasingly the mesh is the operator who collects the agent telemetry by default.

the other tell is what's missing from the consumer agent demos. none of the viral 'agent does my job' clips show six-hour runs, multi-machine handoffs, or persistent credential vaulting. they show single-session, single-host, single-tool flows. that is the gap between agent-as-feature and agent-as-runtime, and the runtime side is where the recurring revenue lives.

the steelman

the counter is real. consumer chat surfaces still have the largest install bases in ai by an order of magnitude, and the universe of people who will ever ssh into a tmux session is small. if the next generation of agents collapses the dev primitives into a chat-shaped abstraction (think: an agent that provisions its own ephemeral runtime invisibly behind a single text box), then the runtime layer becomes plumbing and the consumer surface keeps the value. openai's app posture and apple's eventual on-device assistant are both bets that this collapse happens.

that outcome is possible. it is not the way to bet. the abstraction that hides the primitives still has to run on top of them, and whoever owns the primitive layer underneath gets the meter regardless of what the wrapper looks like. azure runs the runtime either way.

what to do with this

if you are building an agent product, the pricing question is not 'what does the chat interface cost' but 'where does the runtime live and who collects the telemetry.' if you are allocating against the agent thesis, the durable position is the dev-environment owner, not the chat-app owner. github copilot is mispriced as a coding assistant; it is the front of a runtime distribution business that microsoft already monetizes through azure on the back end.

the agent OS war was never going to be decided in a text box. it was going to be decided wherever long-running processes, persistent state, and credentialed tool access already lived. that turned out to be the terminal. and the terminal, increasingly, ships from redmond.