Tailscale Release Notes

Follow

169 release notes curated from 30 sources by the Releasebot Team. Last updated: Nov 14, 2026

Get this feed:
  • Nov 13, 2026
    • Date parsed from source:
      Nov 13, 2026
    • First seen by Releasebot:
      Nov 14, 2026
    Tailscale logo

    Tailscale

    Tailscale Terraform Provider v0.30.0

    Tailscale adds route-selection controls to its Terraform provider, including MagicRoute enablement, and deprecates the regional routing setting.

    v0.30.0 of the Tailscale Terraform Provider has been released with the following changes:

    New

    Set the route_selection attribute in tailscale_tailnet_settings to select the route selection method for your tailnet. This can be used to enable MagicRoute in your tailnet.

    Changed

    Use of the regional_routing_on attribute in tailscale_tailnet_settings will continue to be supported, but is deprecated in favor of route_selection.

    Original source
  • Nov 12, 2026
    • Date parsed from source:
      Nov 12, 2026
    • First seen by Releasebot:
      Nov 13, 2026
    Tailscale logo

    Tailscale

    Tailscale v1.104.7

    Tailscale updates Go to 1.27.4 to fix TLS ClientHello issues that could disrupt connections to its control plane.

    All Platforms

    Changed: Go is updated to Go 1.27.4, to explicitly resolve an issue in TLS ClientHello where some middleboxes break connections to the Tailscale control plane.

    Original source
  • All of your release notes in one feed

    Join Releasebot and get updates from Tailscale and hundreds of other software products.

    Create account
  • Nov 12, 2026
    • Date parsed from source:
      Nov 12, 2026
    • First seen by Releasebot:
      Nov 13, 2026
    Tailscale logo

    Tailscale

    Tailscale Kubernetes Operator v1.104.7

    Tailscale fixes its Kubernetes Operator API server proxy to identify callers by connection source address, ignoring X-Forwarded-For.

    A new release of the Tailscale Kubernetes Operator is available. For guidance on installing and updating, refer to our installation instructions.

    Fixed

    The Kubernetes API server proxy identifies a caller only by the connection's source address, and no longer uses the X-Forwarded-For header.

    Original source
  • Nov 10, 2026
    • Date parsed from source:
      Nov 10, 2026
    • First seen by Releasebot:
      Nov 11, 2026
    Tailscale logo

    Tailscale

    Tailscale v1.104.6

    Tailscale fixes dormant connection and Windows standby issues, improves macOS network extension handling, and resolves DNS problems during network transitions.

    All Platforms

    Fixed: A rare connectivity issue that affected dormant connections has been resolved.

    Windows

    Fixed: A connectivity issue that occurred when resuming from Modern Standby on devices without Always On or Unattended mode enabled is resolved.

    macOS

    Fixed: Error handling has been improved when multiple network extensions are present.

    Fixed: An issue where MagicDNS could select a suffix-scoped DNS resolver during network transitions has been resolved.

    Fixed: A DNS configuration race condition that could occur during network transitions has been resolved.

    Original source
  • Nov 10, 2026
    • Date parsed from source:
      Nov 10, 2026
    • First seen by Releasebot:
      Nov 11, 2026
    Tailscale logo

    Tailscale

    Share skills across users, teams, and agents with Aperture

    Tailscale updates Aperture with shared skill creation, importing, and organization-wide distribution over MCP, helping teams keep AI workflows aligned across users and agents.

    Giving an AI agent skills is a great way to take token-hungry, non-deterministic workflows and turn them into faster, cheaper, reproducible tasks. However, these skills are typically attached to individual users and specific agents. This isolation makes it difficult for co-workers and companies to quickly and safely share AI best practices and align on process improvements. Without a way to easily share skills, valuable knowledge ends up fragmented, out of date, or lost.

    This is why we’re updating Aperture to serve as a single place to create, organize, and share skills across your team or organization. Today, keeping skills synchronized across different people or agents involves a lot of copying and pasting. It’s the AI equivalent of pinning down that Q4REPORT_FINAL_V2_NEW_20261110.XLSX spreadsheet buried in a 100-message thread. With the speed at which AI moves, it’s not tenable to keep in sync this way.

    Importing and creating skills in Aperture

    Aperture serves as both a repository for individual user skills to use across agents, and for organization-level skills to share across teams. Whether you’re a user or admin, if you have existing skills to bring into Aperture, you can import them in four ways.

    • Upload your skills — The most straightforward way of adding existing skills to Aperture: upload the SKILL.md, .zip file, or paste the Markdown.
    • Sync a GitHub repo — If you already have a bundle of skills in a public repository, paste the link and Aperture will import them.
    • Use a URL — If you’d like to bring in skills from a third party (like stripe.com) and they support the .well-known skill discovery specification, give Aperture the URL and it presents you with a list of skills to import.
    • Ask your agent — If you add Aperture as an MCP server to your agent, you can ask your agent to add any existing skills to Aperture through MCP.

    You can also create skills in Aperture itself: select Add from the Skills menu, or use the pre-built Skill Creator skill inside Aperture. The Skill Creator skill uses new MCP tools added to the Aperture MCP gateway, so you can ask any agent connected to Aperture’s MCP endpoint (or Aperture Chat) to create, update, and delete your skills.

    Aperture exposes MCP endpoints that list and read all of your LLM sessions, no matter which agent created them. That means you can improve a skill across all of your agents. Use a skill, have another agent review your sessions with that skill, then ask for improvements — with all the progress retained across all your agents, through Aperture.

    Distributing skills over MCP

    To make distributing your constantly evolving skills easier, we’ve implemented the brand-new Skills over MCP spec in Aperture. Aperture delivers identity-based access to LLMs, MCP servers, and skills across your organization’s AI deployments.

    Using Skills over MCP with Aperture, two things are now possible:

    • An individual can distribute skills across their agents or computers.
    • Aperture admins can decide which skills are shared with individuals or teams based on their identity.

    Not every agent supports the Skills extension yet. As agents add support, Aperture works with them automatically.

    Building toward safe, collaborative AI

    In many ways, learning and working with AI is often an individual (or even lonely) experience. It’s time we made it easier to share what we learn with others (humans, specifically). A seamless skill-sharing experience is one small step in that direction. We intend to take many more.

    If you’re exploring what simple, secure, collaborative AI enablement looks like at your organization, we’d love for you to give Aperture a try and reach out with any feedback.

    Original source
  • Similar to Tailscale with recent updates:

  • Nov 9, 2026
    • Date parsed from source:
      Nov 9, 2026
    • First seen by Releasebot:
      Nov 11, 2026
    Tailscale logo

    Tailscale

    Grok Bot has a Tailscale integration—and now you can, too

    Tailscale releases OAuth apps for general availability, letting AI agents securely connect to private tailnet resources without exposing them to the public internet. Agents act under the authorizing user’s identity, with access governed by tailnet policies and optional device posture controls.

    Your AI agent can help you get work done, but some of the most useful tools and data it could work with are locked away on your private network, for good reason. You shouldn’t have to expose your internal infrastructure to the public internet just to make it accessible to an AI agent.

    Tailscale OAuth apps, now generally available, provide that connection between a user’s Tailscale network (tailnet) and agents through a standard OAuth 2.0 authorization flow. Unlike Tailscale’s existing OAuth clients, which create tag-owned devices under a shared service identity, OAuth apps act on behalf of the user who authorizes them. Devices provisioned this way carry the user’s identity, so tailnet access policies, audit logs, and device quotas all still apply, just like for any other device you own.

    This flow is already in production: Grok Bot can use OAuth apps to connect to private Model Context Protocol servers on your tailnet, without exposing them to the public internet. You stay in control of what it can access, and you’re not pasting keys or secrets anywhere.

    Give your agent access, without giving it access to everything

    When you connect Grok Bot to Tailscale, it joins your tailnet as a device associated with your user identity. Like any other device on your tailnet, Grook Bot follows your tailnet policy controls.

    You might want Grok Bot to access an internal MCP server, but not everything else your laptop can reach. With Tailscale’s device posture checks, you can do exactly that.

    When you add Grok Bot to a tailnet on our Premium or Enterprise plan, it will have a custom posture attribute that you can use in your tailnet policy to control which resources it can access, separately from your other devices. On other plans, you can achieve similar control by assigning a tag to Grok Bot’s device after authentication and using tag-based access rules instead of combining user identity with device posture.

    For example, this policy lets members of your engineering team access production databases from their regular devices, while Grok Bots associated with those engineers’ identities can access only designated MCP servers:

    {
      "postures": {
        "posture:grokbot": ["custom:grokbot == true"],
        "posture:human": ["custom:grokbot NOT SET"]
      },
    
      // All access rules require posture:human unless otherwise specified
      "defaultSrcPosture": ["posture:human"],
    
      "grants": [
        {
          // Engineers can access production databases. The defaultSrcPosture applies here.
          "src": ["group:engineering"],
          "dst": ["tag:production-db"],
          "ip": ["tcp:5432"]
        },
        {
          // Grok Bots owned by engineers can access MCP servers.
          "src": ["group:engineering"],
          "srcPosture": ["posture:grokbot"],
          "dst": ["tag:mcp-servers"],
          "ip": ["tcp:443"]
        }
      ]
    }
    

    The defaultSrcPosture ensures that existing access rules don’t apply to Grok Bot devices. The explicit srcPosture on the second grant makes an exception, allowing Grok Bot to reach MCP servers without inheriting the user’s broader network access.

    Custom posture attributes are available on Tailscale Premium and Enterprise plans.

    Get started

    Connect Grok Bot to your tailnet using the Tailscale plugin in the Grok Bot desktop app.

    Interested in building your own integration? Start with the OAuth Apps documentation and device provisioning guide.

    Original source
  • Nov 5, 2026
    • Date parsed from source:
      Nov 5, 2026
    • First seen by Releasebot:
      Nov 6, 2026
    Tailscale logo

    Tailscale

    DERP server location and IP address changes for India

    Tailscale moves its India DERP servers from Bengaluru to Mumbai, updating their IP addresses while keeping region ID 6.

    Changed: The India DERP servers have moved from Bengaluru (blr) to Mumbai (bom). The region ID remains 6.

    Changed: The IPv4 and IPv6 addresses for these servers have changed. If you use custom firewall settings that rely on these addresses specifically, refer to the information in our DERP map and make the necessary updates. Otherwise, no action is required.

    Original source
  • Nov 2, 2026
    • Date parsed from source:
      Nov 2, 2026
    • First seen by Releasebot:
      Nov 3, 2026
    Tailscale logo

    Tailscale

    Tailscale v1.104.5

    Tailscale improves SSH, Serve, and tsnet reliability on lossy networks, fixes SSH session and restart issues, resolves a Windows installer privilege escalation risk, and improves connection reliability on Apple platforms.

    All Platforms

    Fixed: Connectivity stalls affecting Tailscale SSH, Tailscale Serve, and tsnet on lossy networks are resolved.

    Fixed: Tailscale SSH sessions no longer disconnect when a check mode approval expires.

    Fixed: An issue that could cause Tailscale SSH restarts to hang or background tasks to terminate is resolved.

    Windows

    Fixed: An issue in the Windows .exe installer that could lead to privilege escalation at install time has been resolved. Existing installations do not need to be reinstalled.

    macOS

    Fixed: Connection reliability is improved when the network reports an unreachable destination.

    iOS

    Fixed: Connection reliability is improved when the network reports an unreachable destination.

    tvOS

    Fixed: Connection reliability is improved when the network reports an unreachable destination.

    Original source
  • Oct 28, 2026
    • Date parsed from source:
      Oct 28, 2026
    • First seen by Releasebot:
      Oct 29, 2026
    Tailscale logo

    Tailscale

    Tailscale SSH: Findings and fixes

    Tailscale releases v1.104.4 with fixes for security vulnerabilities in Tailscale SSH, Serve, and Funnel, plus architectural safeguards to strengthen protection. The update addresses privilege-boundary issues and is recommended for users of Tailscale SSH.

    Last weekend, a security researcher published a report titled “Tailworm,” describing potential vulnerabilities in Tailscale SSH and other Tailscale features.

    We know that people rely on Tailscale to protect access to important systems, and we understand how concerning it is to learn that some of those protections didn’t work as intended.

    Over the past several days, our engineering and security teams have identified issues that require urgent attention, reviewed related code, and developed and tested fixes. Beyond addressing the individual vulnerabilities, we’ve also introduced architectural safeguards designed to protect against broader classes of related issues.

    Those fixes are now available in Tailscale v1.104.4.

    We know that earning your trust means more than simply releasing a patch. You deserve to understand what happened, how it might have affected you, and what we’ve done to make things better. That’s what we want to explain here.

    A little background on Tailscale SSH

    Tailscale supports standard SSH connections over your tailnet, including OpenSSH. Tailscale SSH goes further by providing a built-in SSH server that uses Tailscale identities and access policies to control access.

    Administrators can define who can connect to which machines, which local Linux/Unix users they can connect as, and whether connections require an additional authentication check. Tailscale SSH also supports visibility features such as session recording and auditing within the platform.

    SSH servers, including OpenSSH and Tailscale SSH, need elevated system privileges to perform certain operations, such as starting sessions as different Unix users. The challenge is ensuring those privileges don’t extend to the connected user’s session, where commands and features such as SSH forwarding must remain within the permissions granted to that user.

    What we found

    The Tailscale SSH vulnerabilities identified primarily concerned how permissions were enforced after a connection had been authorized, rather than the authentication and access policy checks that determine who can connect. Exploitation of these vulnerabilities requires an attacker to already have access to an authorized device in the tailnet.

    Under certain conditions, an authenticated SSH session could perform operations beyond the privileges of its configured local user, including through SSH forwarding. These privilege boundaries are an important part of Tailscale SSH’s security model, and in these cases we didn’t enforce them correctly.

    It’s important to note that the vulnerabilities don’t allow an unauthenticated attacker to connect to arbitrary Tailscale SSH servers. Exploitation requires an existing foothold on an authorized peer in the tailnet, with SSH access explicitly permitted in the tailnet policy file, along with the conditions necessary to exercise the vulnerable functionality.

    The report’s name has also prompted questions about whether these vulnerabilities constitute a computer worm. They don’t describe self-replicating malware spreading automatically between machines. Instead, this would be better described as lateral movement limited to connections allowed by a tailnet policy file.

    In addition, the access between machines was still gated by the tailnet policy file. Based on our investigation, an attacker could reach only machines the tailnet policy file already permitted SSH connections to. The vulnerabilities could only be exploited after an attacker had gained the necessary access.

    The report also describes five findings in Tailscale Serve and Funnel. Three were bugs, and Tailscale v1.104.4 fixes them. The other two describe behavior that works as designed: bypassing the Funnel attribute check requires local admin access, and TS_SERVE_ALLOW_ALL_INTERFACES is an opt-in setting meant to expose Serve beyond the tailnet.

    How we responded

    On Friday, October 23, concerns about Tailscale SSH began circulating on social media. Our engineering and security teams began investigating immediately, with help from external security specialists.

    We received the researcher’s report on the morning of Saturday, October 24, and the researcher published it two hours later. By that point, our engineering and security teams were already investigating several related issues and working on fixes.

    Once the report was provided, we used it to ground our in-progress investigations, ensure coverage of the public findings, reproduce the relevant issues, and accelerate work on fixes. We also expanded our review of the affected code to make sure we were addressing the underlying problems rather than individual symptoms.

    Over the weekend and into Monday, our engineers worked through the fixes and tested the changes, paying particular attention to Unix privileges and SSH forwarding.

    On Monday, October 26, we published an investigation update with our initial assessment and recommended precautions.

    The resulting fixes are available in Tailscale v1.104.4.

    A clarification about app connectors

    The report also identified a vulnerability in Conn25, the next generation of our app connectors. Conn25 is still in pre-production and hasn’t been released.

    We were already aware of this issue, and addressing it is one of the reasons we haven’t released Conn25. Finding and fixing issues like this before a feature reaches users is an important part of our development process. The stable app connectors available today are not affected.

    Security bulletins and customer actions

    We’re publishing four security bulletins covering the confirmed findings that warrant separate disclosures. Each explains the affected functionality, conditions required for exploitation, impact, and remediation:

    • TS-2026-014
    • TS-2026-015
    • TS-2026-016
    • TS-2026-017

    The vulnerabilities described above are addressed in Tailscale v1.104.4. If you use Tailscale SSH, we recommend updating to this release or later.

    Beyond updating, we also recommend reviewing how SSH access is configured across your tailnet. A few things worth checking:

    • Review your Tailscale SSH policies to make sure access is limited to the users and devices that need it.
    • Consider SSH check mode for sensitive systems, which requires an additional authentication check before granting access.

    Continuing the work

    We value independent security research and welcome reports that help us improve Tailscale. We’ll apply what we’ve learned from this investigation to our ongoing security work. If you discover a vulnerability, please contact us at [email protected] so we can investigate and work with you to help keep Tailscale’s community safe.

    Original source
  • Oct 28, 2026
    • Date parsed from source:
      Oct 28, 2026
    • First seen by Releasebot:
      Oct 29, 2026
    Tailscale logo

    Tailscale

    Tailscale v1.104.4

    Tailscale’s internal-only v1.104.3 release fixes four security vulnerabilities in Tailscale SSH and Serve, restricting access to privileged Unix sockets, preventing unbounded memory growth, and isolating HTTP/2 request capabilities.

    Note: v1.104.3 was an internal-only release.

    All Platforms

    • Fixed: Tailscale SSH performs Unix socket forwarding on behalf of the authenticated user rather than as root, preventing authorized peers from using local and remote forwarding to reach root-only Unix sockets such as the Docker socket or the tailscaled local API. This fix addresses a security vulnerability described in TS-2026-014.
    • Fixed: Tailscale SSH bounds the memory used for session handling and releases it when the peer disconnects, preventing denial of service through unbounded memory growth in tailscaled from continuous window-change messages and environment variable appends. This fix addresses a security vulnerability described in TS-2026-015.
    • Fixed: Tailscale Serve restricts TCP forwards to Unix socket backends and revalidates backend paths on each connection, preventing access to privileged Unix sockets such as the tailscaled local API socket. This fix addresses a security vulnerability described in TS-2026-016.
    • Fixed: Tailscale Serve derives per-request capabilities from the request context rather than from a context shared across all HTTP/2 streams, preventing Tailscale-App-Capabilities values from one mount from being sent with requests for another. This fix addresses a security vulnerability described in TS-2026-017.
    Original source
  • Oct 28, 2026
    • Date parsed from source:
      Oct 28, 2026
    • First seen by Releasebot:
      Oct 29, 2026
    Tailscale logo

    Tailscale

    Tailscale Terraform Provider v0.29.3

    Tailscale releases Terraform Provider fixes for DNS configuration, tailnet key updates, and ACL policy validation at plan time.

    v0.29.3 of the Tailscale Terraform Provider has been released with the following changes:

    • Fixed: tailscale_dns_configuration resource reconciles updates in keeping with the user-specified order of nameservers.
    • Fixed: tailscale_dns_configuration resource defines split_dns as a set, not a list.
    • Fixed: tailscale_tailnet_key resource no longer panics on updates when the key is not found.
    • Fixed: tailscale_dns_configuration no longer displays a stale alpha warning.
    • Changed: tailscale_acl resource validates the policy file at plan time.
    Original source
  • Oct 27, 2026
    • Date parsed from source:
      Oct 27, 2026
    • First seen by Releasebot:
      Jul 1, 2026
    • Modified by Releasebot:
      Nov 14, 2026
    Tailscale logo

    Tailscale

    Device Provisioning with OAuth Apps

    Tailscale makes OAuth App creation and management for Device Provisioning available through its API.

    Changed: Create and manage OAuth Apps for Device Provisioning with the Tailscale API (GA).

    Original source
  • Oct 26, 2026
    • Date parsed from source:
      Oct 26, 2026
    • First seen by Releasebot:
      Oct 26, 2026
    Tailscale logo

    Tailscale

    Where Tailscale VPN ends and Tailscale PAM begins

    Tailscale introduces PAM Beta, bringing identity-based access controls, credential management, and session logging to infrastructure services such as databases, SSH, Kubernetes, and web apps, all managed through the Tailscale admin console.

    One of your jobs as a new Tailscalar (yes, this is how we spell it) is to learn as much as you can about all the company’s products and how they work. Tailscale’s VPN wasn’t too hard for me to wrap my head around—it’s not a traditional VPN, but it uses VPN technology, and I had already run into it as I poked at homelab experiments. The Aperture AI platform also wasn’t too hard to understand—one tool to unify and control access to a bunch of disparate large language models from different providers (and, more recently, to help tame homelabs).

    Tailscale PAM (or “privileged access management”) was harder to understand, at least at first. At a very high level, both Tailscale PAM and our VPN talk about a lot of the same things: using identity to establish secure connections from any network, robust access controls to ensure no one can access anything they’re not supposed to, and even the ability to manage and log SSH sessions for later evaluation.

    Doesn’t a VPN also offer management of privileged access?

    To attempt a quick summary: Tailscale VPN is there to secure connections between users, devices, and apps. Tailscale PAM makes infrastructure access easier to set up and administer, and make logging in seamless for your users. It eliminates the need for distributing long-lived, app-specific credentials, and gives you more visibility into who did what using what machine and when.

    OK, so what is PAM?

    Tailscale’s VPN creates a peer-to-peer mesh overlay network called a tailnet. This is a fancy way of saying that it creates a virtual network that can (1) lay over top of and span many physical networks and (2) connect one device directly to another device without the data passing through some kind of server or other mediator in the middle, creating a point-to-point “mesh” of connections.

    We prefer this VPN setup to a traditional “hub-and-spoke” VPN with a server in the middle for all kinds of performance, privacy, and ease-of-use reasons. We detail these exhaustively in our “What is Tailscale?” post.

    The first thing to know about Tailscale PAM is that it requires you to configure Tailscale PAM connectors. These are devices (or servers, or containers, or VMs) running the Tailscale PAM connector software, sitting on the same network as the thing you want to access, whether that’s a physical network or a VLAN or something else. You need at least one for every network you want to reach. Each of your devices communicates with the connector via a WireGuard®-encrypted tunnel, and then the connector mediates your access from there.

    Wait, isn’t this just going back to the same kind of hub-and-spoke model that we’ve complained about? Sort of. We have made it trivial to add multiple Tailscale PAM connectors per network for redundancy and security reasons, so your spokes aren’t reliant on a single hub. The difference is in the additional features that a Tailscale PAM connector enables.

    Frictionless connections

    Tailscale’s VPN already uses your identity—whatever credentials you use to sign in—to give you access to tailnets. Tailscale’s VPN uses identity to control exactly which users and devices on those tailnets you can communicate with, using grants and ACLs. Tailscale PAM uses the same identity layer, and the same admin console, to go one step further. Using the Tailscale PAM Connector, administrators can control access to specific services and applications, including SSH, multiple flavors of databases, Kubernetes clusters, Remote Desktop sessions, and web apps.

    Tailscale PAM also improves on manually setting up Tailscale Services or hand-configuring tags and grants in the admin console. For starters, there’s no need to run the Tailscale client software on every server you want to provide access to.

    Once you’re set up with PAM Connectors, Tailscale PAM has a built-in list of common PAM services to choose from, with default ports filled out. It approves access in real time, checking every single connection from every single user every time it happens. And Tailscale PAM can set more granular permissions for specific resources—for example, allowing a user to add to a certain part of a database, while blocking them from deleting any existing data.

    And the connector isn’t just there to keep people out; Tailscale PAM makes it easier to let people in, too. The Tailscale PAM connector can handle credential injection and authentication tokens for services, which means that if a database or another service has its own password, you no longer need to share that with everyone who needs access. If the credentials for that database need to be changed, you can change them in the admin console (or an external secrets manager) without having to redistribute the credentials or interrupt anyone’s workflows.

    If your users have the Tailscale client installed, the client can even open and authenticate locally installed applications, so there’s no need for users to change the tools they’re comfortable with just so they can access a Tailscale PAM service.

    But because the Tailscale PAM connector is on the same network as the service you’re reaching, you don’t need to install a Tailscale client directly on every client device. The connector handles incoming connections, and clients can access services through a browser, if you’ve configured it that way. They’ll still need to sign in so that their identity can be verified, but if they can’t (or don’t want to) install client software, it isn’t required.

    Adherence to the “principle of least privilege” means it’s easy to extend temporary access to people who need it, when they need it. If you update a server once a month but it shouldn’t be accessed otherwise, or if you’ve brought in a contractor for a one-off project, PAM gives you some extra flexibility around providing access.

    Records kept

    Using Tailscale PAM to simplify access is a great feature in and of itself—you’ll no longer need to wonder who still has that old database password written on the secret Post-It in their desk. But the hero feature of Tailscale PAM is probably the paper trail. Trying to reconstruct exactly what happened when you’re troubleshooting a stubborn error or trying to recover from a security incident is stressful and chaotic at the best of times—adding uncertainty and mystery on top of that doesn’t help.

    At a minimum, Tailscale PAM sees and logs user identity, the user’s IP address, the user’s IP-derived geographic location, information about the user’s device, when the connection happened, and how long the connection lasted. This is already a whole lot more specific than you can get when a dozen people are all sharing the same database credentials.

    For many services, you can extend past these into the what with optional session recording. For database sessions, the Tailscale PAM connector records a query log, including any error messages. For SSH sessions, the text contents and a video replay are available. You can also record HTTP, Kubernetes, and S3 sessions.

    Recordings are generally saved and stored in Tailscale-managed storage, but for those wanting more control over their data, we support storing recordings in Amazon S3 storage in our Premium plan. This can make it easier to access and audit this data with third-party tools.

    That’s the power of PAM

    If the difference between Tailscale VPN and Tailscale PAM still isn’t making sense to you, think of it this way: Tailscale PAM is the security camera for a door you’ve locked using Tailscale VPN. Tailscale VPN gets you the connection; Tailscale PAM makes that connection even more useful and flexible. If Tailscale VPN is the base game, Tailscale PAM is the well-regarded expansion pack.

    These tools are designed to complement each other and work together. As of the Tailscale PAM Beta release, managing PAM features is handled in the same Tailscale admin console you use for VPN connections.

    Original source
  • Oct 21, 2026
    • Date parsed from source:
      Oct 21, 2026
    • First seen by Releasebot:
      Oct 22, 2026
    Tailscale logo

    Tailscale

    Tailscale v1.104.2

    Tailscale updates Go to distrust compromised TLS intermediates and fixes Windows disconnections and DNS routing issues, along with macOS menu activation and service-search bugs.

    All Platforms

    Changed: Go is updated to version 1.27.3, to explicitly distrust compromised TLS intermediate certificates as described in security bulletin TS-2026-013.

    Windows

    • Fixed: An issue where the Windows client could repeatedly disconnect on large tailnets while processing peer updates is resolved.
    • Fixed: A regression where Windows clients made 100.100.100.100 the system's primary DNS resolver when MagicDNS was disabled (or a device from another tailnet was shared in) and no global nameservers were configured, causing all DNS queries to be proxied through Tailscale instead of only the configured split DNS domains is resolved.

    macOS

    • Fixed: Menu construction timing could result in the macOS app not fully activating and, on macOS Ventura 13, rendering a malformed menu.
    • Fixed: Searches entered on the services tab do not inadvertently filter pinned services on the pinned tab.
    Original source
  • Oct 19, 2026
    • Date parsed from source:
      Oct 19, 2026
    • First seen by Releasebot:
      Oct 21, 2026
    Tailscale logo

    Tailscale

    MagicRoute: Routing without physical routers

    Tailscale releases MagicRoute in beta for Premium and Enterprise customers, helping clients choose and stay with the nearest healthy subnet router, app connector, or service host. The new routing option aims to improve stability, avoid unnecessary connection breaks, and support custom DERP servers.

    Today we’re announcing MagicRoute, a new way to select the best available backend when you’re running more than one. MagicRoute uses signals, like location, to find the best subnet routers and app connectors, and stick with them more reliably. It’s available now, in beta, for Premium and Enterprise customers.

    The best kind of technology is the kind you never think about. DNS and routing are network features that very much want you to think about them, and which nobody wants to configure or troubleshoot. We designed MagicDNS to Just Work like people expect it to. Now we’ve designed MagicRoute with the same goal, to Just Work for modern teams with distributed workforces and architectures.

    Why MagicRoute?

    Let’s say you have two overlapping subnet routers—advertising the same routes on different machines. You might add a second subnet router for redundancy, so a crashed machine doesn’t take down the subnet. Or for capacity, when one subnet router can’t handle all the traffic. Or for proximity, by spreading subnet routers around the world.

    Once you introduce the second subnet router, how does your client choose?

    Our last attempt was regional routing. This grouped subnet routers, app connectors, and Tailscale Service hosts (just “connectors” from here onward) into regions based on their home DERP servers. Your client would be matched with connectors in the same, or the nearest, DERP region.

    But as more customers adopted regional routing, we learned that relying on DERP regions would sometimes lead to bad matches. When a connector is sitting on a fast backbone or major exchange point, its latency to several DERP regions could be nearly identical, often within a couple milliseconds of each other. Minuscule amounts of jitter can lead to the connector flapping between those regions: choosing one as its home, jumping to the other, and then bouncing back.

    When a connector flaps, every client on it breaks existing connections, dropping SSH sessions or interrupting large file transfers partway. And if a client switches connectors, the other clients on its DERP home will also make that switch, causing a cascade of failures. We like fast connections, but usually not at the expense of stability.

    Even if your connectors aren’t in a fancy datacenter, bad internet weather would also break regional routing for similar reasons. A temporary slowdown could cause your connector to pick a DERP home in another country, triggering clients to switch connectors and break connections.

    And if you’re hosting custom DERP servers, you’ve been excluded from regional routing because their DERP regions are incompatible with our public regions.

    All of this made it clear that DERP regions were the wrong criteria. The internet is too complex to make routing decisions based on one set of data points. So we asked ourselves what it would take to make routing Just Work. That’s where MagicRoute comes from.

    How MagicRoute works

    MagicRoute scores and ranks each connector in a tailnet from the client’s point of view. Clients are matched to their top choice for each subnet route and app. When there’s a tie for first place, clients are spread fairly among those top connectors.

    In this example below, client A has two top choices, but only one of them is healthy. Client C also has two top choices, but since they’re both healthy, it has an even chance of picking either one.

    Coarse location is the signal behind MagicRoute scores today; we guess your location and keep only the precision necessary to match you to your nearest connector. We start by comparing approximate distances, because they don’t change if you don’t move, unlike latency measurements. Clients keep on using their preferred connector, so long as it’s healthy, which avoids breaking connections unnecessarily.

    Since MagicRoute doesn’t rely on DERP regions any more, it also works in tailnets with custom DERP servers.

    MagicRoute also affects how we handle unhealthy connectors. When a client’s preferred connector goes offline, we work down the ranked list of connectors until we find a healthy one. In this example below, both of client A’s choices are unhealthy, so it fails over to its next best choice.

    Route selection in the console

    With the introduction of MagicRoute, tailnet administrators will see a change in their admin console. Instead of one switch that controls regional routing, there is now a Configure section (Settings > General > Route Selection > Configure). On Premium and Enterprise plans, you’ll now see four options:

    • Active-passive failover: One primary connector serves the tailnet, with others standing by until it goes offline.
    • Regional routing: Distribute clients using connectors in the same DERP region.
    • Regional routing with in-region failover: Use one primary connector for all clients in a DERP region, with others standing by until their region’s primary goes offline. This option is not available without contacting support.
    • MagicRoute: Each client selects the nearest healthy machine, and keeps active sessions steady instead of switching back and forth.

    You can read more about all of these options at our docs page.

    MagicRoute is intentionally a single option for a whole tailnet, with no opt-outs for individual connectors. Routing is difficult to fine-tune; setting rules for individual nodes may lead to unexpected interactions and bad behavior.

    More magic over time

    We’re improving MagicRoute as we gather your feedback. We’re looking into reachability checks, where the clients themselves ask, “Can I actually get packets to this connector?” And we’re considering additional signals for MagicRoute’s connector scoring system.

    MagicRoute aims to offer a different experience. We’re naming it “Magic” to force ourselves to live up to the expectations we’re setting. It’s another step toward our ultimate mission of making safe connections effortless.

    MagicRoute is in beta today for Premium and Enterprise customers. All client versions support MagicRoute for subnet routers, app connectors, and Tailscale Service hosts. Clients since version 1.86.0 support MagicRoute when suggesting recommended exit nodes.

    You can read more about MagicRoute in our docs. More importantly, try out MagicRoute, and let us know how it works for you. If it could work better, send a Feedback ticket to help us make it more magical.

    Original source
Releasebot

Curated by the Releasebot team

Releasebot is an aggregator of official release notes from hundreds of software vendors and thousands of sources.

Our editorial process involves the manual review and audit of release notes procured with the help of automated systems.