How Tailscale Is Becoming the Backbone of AI

There's a specific kind of infrastructure creep that happens in developer communities — a tool starts as a neat trick for sysadmins, gets passed around, and one day you look up and it's load-bearing. Tailscale is somewhere in that transition right now, and the AI agent wave is accelerating it considerably.

David Ondrej's recent video guide on using Tailscale with AI agents is worth paying attention to — not primarily as a tutorial, but as a signal. Ondrej is building the kind of multi-agent, multi-VPS setup that a growing cohort of indie developers and small teams are assembling right now, and the networking problem he's solving is real: how do you manage a fleet of AI agents running across machines you don't physically control, without turning every server into an open wound on the internet?

His answer is Tailscale. And it's not a bad one. But there's a fuller picture worth drawing.

What Tailscale Actually Does

At its core, Tailscale builds a private mesh network across all your devices — laptops, VPS instances, phones, whatever — using WireGuard as the underlying protocol. WireGuard is the current gold standard for VPN performance: lean, fast, and auditable. The elegant thing about Tailscale's implementation is that your machines connect peer-to-peer, so traffic doesn't route through a middleman; it goes directly between nodes. That matters both for latency and for the security argument.

The immediate practical benefit Ondrej demonstrates: once your machines are on a Tailscale network (a "tailnet"), you can shut down every publicly exposed port. No more SSH exposed to the open internet, where bots are probing 24/7. "Every open port is a point of exposure," Ondrej says. "It's a weakness since there are countless bots scanning the whole internet non-stop." For solo developers running VPS instances for AI workloads, that's not paranoia — it's just accurate.

Authentication is tied to an identity provider like Google or GitHub, which means no SSH key sprawl. If someone leaves your team or a device is compromised, you revoke access once and it's done across the whole network. For small teams managing distributed infrastructure, this is a meaningfully better operational model than the traditional approach of rotating SSH keys and hoping everyone updated their ~/.ssh/authorized_keys.

Access control lists (ACLs) add another layer: you can specify granular rules about which agents can reach which machines, so a compromised node doesn't automatically become a pivot point across your entire fleet.

The Multi-Agent Case

The part of Ondrej's video that's genuinely new — or at least newly relevant — is the framing around AI agent orchestration. The argument is straightforward: if you're running multiple AI agents across multiple machines (a Hermes instance on one VPS, OpenClaw — a personal AI assistant project on GitHub — on another, something else on a Mac studio), managing them individually is brutal. Each crash, each model update, each configuration change is a separate SSH session you have to remember credentials for.

With everything on a tailnet, a single orchestrator agent running on your local machine can reach all of them by hostname. Ondrej walks through having Codex install Hermes agent on a remote VPS, lock down the firewall, and swap model configurations — all via natural language prompts, without him touching the remote terminal directly. "You just need to give it the high level goal and let it do what it does," he says.

The video also introduces Aperture, Tailscale's AI gateway product, as a solution to the API key management problem. If you're running seven agents across five machines, you don't want seven separate copies of your OpenRouter or Anthropic API keys scattered across different machines with different levels of security. Aperture joins your tailnet as a node; agents reach it privately to fetch credentials. Your real API keys live in one place and never touch individual VPS instances. It's a reasonable answer to a problem that's going to bite a lot of people who don't have a good answer yet.

According to Ondrej's account, Tailscale's free tier supports unlimited devices and up to six users — a figure also listed by FreeTier.co — though Tailscale has adjusted its pricing tiers before, so it's worth confirming current limits directly on their site before building around them.

The Part the Tutorial Doesn't Cover

Here's where I want to pull back, because Ondrej's video is a product walkthrough with a Hostinger sponsorship, and there are structural questions about Tailscale that matter for people building serious infrastructure.

Tailscale is not fully open source in the way the phrase usually implies. The client code — the CLI, tsnet — is open source, and Tailscale maintains a meaningful open source program. But the coordination server, which is the thing that manages your tailnet, authenticates devices, and distributes keys, is Tailscale's proprietary control plane. You're not running that yourself. Your mesh network is genuinely peer-to-peer once established, but the establishment and management layer runs on Tailscale's infrastructure.

This is not a secret — Tailscale is upfront about it — but it's something the self-hosting community has opinions about. The relevant project here is Headscale, a community-maintained, open-source reimplementation of the Tailscale control server that you can run yourself. If you want the WireGuard mesh without the commercial coordination plane, Headscale is the path. The r/selfhosted community and various Tailscale-adjacent Discord servers have running debates about when Tailscale's convenience is worth the control-plane dependency and when it isn't.

The Headscale crowd's concerns are worth taking seriously: what happens to your tailnet if Tailscale goes down, changes pricing, gets acquired, or decides your use case doesn't fit their future product direction? These are not hypotheticals — they're the normal lifecycle of developer tooling. The counter-argument is that Tailscale has been thoughtful about maintaining compatibility, their client is open source, and practically speaking, the operational overhead of running Headscale is real. This is a genuine tradeoff, not a gotcha.

For the AI agent use case specifically, there's an additional wrinkle that the indie hacker community is starting to surface: routing production API calls through a commercial control plane means you're adding a dependency to infrastructure that's already dependency-heavy. Your agent traffic stays peer-to-peer, but your authentication and key distribution (via Aperture) runs through Tailscale's systems. At what scale does that become a concern? The honest answer is: probably not at the scale Ondrej's audience is operating at right now. But the architecture decisions you make at ten agents tend to persist to a hundred.

What I'm Watching

The multi-agent networking stack is genuinely unsettled right now. Tailscale is the polished, well-documented answer — and for the vast majority of developers building in this space, it's probably the right starting point. The security model is sound. The operational simplicity is real. The free tier is generous for solo and small-team use.

But the interesting question isn't whether Tailscale solves the problem. It's whether the broader architecture Ondrej is sketching — agent orchestrating agents, all on a private mesh, API keys in a centralized gateway — becomes a stable pattern or splinters as the tooling matures. Right now, it's being assembled by hand from parts that weren't designed together. Tailscale, Aperture, Codex, Hermes, whatever terminal multiplexer you prefer. "If you use the right tools, you don't have to be a 10x developer," Ondrej says — and that's true, but it does require you to have already assembled the right tools.

The concrete thing I'm watching: whether the Headscale project moves to support Aperture-equivalent functionality, or whether a genuinely open, self-hostable alternative to the full Tailscale stack (control plane plus AI gateway) emerges from the community. If it does, the indie developer community will have a real choice between convenience and control. If it doesn't, Tailscale's coordination layer is going to be quietly load-bearing under a lot of AI infrastructure that its builders think of as self-hosted.

That's not a warning. It's just what the terrain looks like from here.

Dev Kapoor covers open source software and developer communities for Buzzrag.