From Tailnet to Platform  🔗 **Source:** [From Tailnet to Platform](https://share.snipd.com/episode/621a6e31-4388-475b-b0ad-340e2261a109) ## Highlights - **Identity As A Network Primitive** - Tailscale is a connectivity platform that bakes user and device identity into every connection, creating private mesh networks with ACLs. - This lets you treat identity as a network primitive, enabling secure access controls without separate VPN hassles. Transcript: David Carney The simplest way to think about Tailscale, and sometimes people ask me, well, what are you building? What do you do? And so explaining it to a layperson is very helpful. And so first and foremost, Tailscale makes it possible to connect any two devices anywhere in the world with strong guarantees of the identity of the user and the device at either end. And if you can do that for any two devices, you can do it for an arbitrary number. So you can start adding like one device, one user, one server, whatever at a time until you have basically what looks like a mesh network and it's completely private. Then you can layer on things like access controls. So you can be like, oh, only these people should be able to access these servers or devices. For instance, the engineers can only access production, the accountants can only access the finance servers, so on and so forth. But fundamentally what you can do with Tailscale is create private networks. And so when we launched the product, I guess we launched it maybe six and a half years ago now, it was pitched as a VPN alternative or zero trust kind of replacement. It does a lot more than what a VPN is, but at the heart of it, it's a connectivity platform as you build private networks that are fully secured and sort of using a mesh overlay pattern. So that's the core of what Tailscale is, and it has been for a very long time. And we've been continuing to build and build and build on top of that. ([Time 0:04:56](https://share.snipd.com/snip/50720eae-dbcd-4589-afd4-57640caf06d1)) - **TSIDP Brings OIDC Inside Your Tailnet** - TSIDP is a private, in-network OIDC/OAuth endpoint that reflects your external identity provider inside your tailnet. - It leverages Tailscale's identity assertions so internal apps can do clickless auth without exposing flows to external IDPs. Transcript: David Carney Well, the thing we started with earlier last year is that we revived a project, an internal project called TSIDP, which, like a lot of things that we've built at Tailscale, we don't do A great job of telling the world about. TSIDP was in our community projects repo. We'd done a bunch of work on it a year or two prior. And for those of you who don't know what it is, and it's probably most of your listeners. That's me too. Yeah, yeah. So TSIDP, you can think of it as a reflection of your identity provider inside of your tail net, right? So you can, it's almost like a locally hosted version of your identity provider that's private to your network. The way it works is that it leverages the fact that every connection in Tailscale has your identity baked into it already. When you provision a tail net, you basically have to say, oh, I'm going to authenticate with Azure or G Suite or Okta or whatever. We don't have our own IDP. We just hook into all the ones that are commonly used out there. Well, once we can start generating keys based on like a handshake or an interaction with your external IDP, every connection has got your identity baked into it. And so if you're sitting inside of a tail net, you know everything that is connecting to you. And so you can actually build a small little application that says that just knows everything or it knows the identity of everybody. And so with that, you can actually create effectively an OIDC provider. So that's what TSIDP is. You can think of it as a locally hosted private OIDC or OAuth endpoint. And that allows you to do all sorts of neat little things. You can start plugging MCP clients and servers into it. You can build little gateway patterns where if you need to do like token exchange, or if you need to do dynamic client registration, you can basically do it with TSIDP. ([Time 0:08:16](https://share.snipd.com/snip/42e0d18f-c71d-4e5b-a0ff-d2111d186309)) - **Run TSIDP Locally For Clickless Login** - TSIDP and TSNet are open source and available now; run TSIDP as a Go binary inside your network for private OIDC. - Install it (e.g., in an LXC on Proxmox), point apps to the local OIDC endpoint, and you get silent login. Transcript: David Carney Well, the code is open source. It's on our community projects page. I think it's github.com/tailscale slash tsidep now. It does support, I believe, OAuth 2.1 nowadays. We brought it up to speed basically to keep pace with the evolving MCP spec last year. So we added a bunch of other stuff to it. But people are using it. A lot of home labbers are already using it. We've got a bunch of what we call tail scale insiders that are using it too. Again, we just haven't talked about it enough. So I don't think enough people are using it or are even aware of it. But it's there and it's open for contributions too if people want to add or extend or make more requests. ([Time 0:14:27](https://share.snipd.com/snip/3e89b00b-7465-43e7-bb9f-dec5d1d32911)) - **TSNet Turns Apps Into Network Nodes** - TSNet is a user-space networking library that makes any Go application appear as a node on your tailnet with an IP and ACLs. - Apps built with TSNet inherit identity, connectivity, and policy, which Aperture uses as a TSNet app. Transcript: David Carney You can think of TSNet as a complete user space stack, like a tail scale stack. It's like a user space networking stack. Again, it's a Go library. So you can compile TSNet into existing Go applications, for instance. And we've done a bit of work on bindings for other languages, but the Go chain is the most mature by far for this. But what using TSNet lets you do is any Go application where you've compiled it in, you can have it show up so it looks just like a node on your network, just like any laptop or iPhone or whatever. And so it shows up as a node, gets its own IP address in the CGNet range, which we use internally. You can apply ACLs to it, policies, all that kind of stuff. You can build applications with that. That's what Aperture is as well. It's fundamentally a TSNet application. So it just shows up as a service. So the nice thing about TSNet is that, yeah, you can turn any kind of service into effectively what appears to be a device. ([Time 0:16:04](https://share.snipd.com/snip/433ee099-8b71-42df-bc6a-87eb45fcfddc)) - **Aperture Centralizes AI Keys And Identity** - Aperture is a private AI gateway running as a tailnet node that centralizes API keys, logging, and identity for every model request. - By routing agent/model calls through Aperture, every API call is tied to a user identity and becomes auditable and controllable. Transcript: David Carney And so for those of you who aren't aware, Aperture is basically an AI gateway built on top of TSNet, which I mentioned earlier, that works inside of your tail net. And you can expose it. Well, there are ways to expose it externally. But essentially, it's a private AI gateway that lets you consolidate all of your API keys inside of it. It just looks like a node on your tail nut like any other would. After spending months and months going to various AI conferences and showing off TSIDP and just talking with all sorts of people, like engineers, CISOs, people in IT, what have you, Time and time again people were saying things like, oh, TSIDP, it's super fascinating, interesting that you guys are working on all this kind of stuff. I see the merits of TailScale. Multi-TailNet, which is this other thing we've been working on internally, is super neat. But what I'm really struggling with is just trying to figure out how to manage API keys because they're all over the place. I can't claw them back because it'll potentially disrupt production or some engineering workflow. We're trying to go really fast as a business. And it's just dangerous. You've got API keys all over the place. People trade them, they get exfiltrated, they get checked in, and they have very large, I guess, well, accounts or credit cards associated with them. And so it's very hard in some cases to track usage because a lot of API calls are inherently anonymous. We were sitting around at a company off-site back in November, just talking about all the things we've been learning over the past few months. And we're like, well, wait a minute. If we built a gateway and we used TSNet for that, the gateway already knows exactly who you are because everything that connects to it over tail scale has identity baked in. So if we put the API keys all inside of the gateway, then you wouldn't need to share an API key with anybody inside of your company. You could just say, oh, if you have a coding agent, just point the coding agent to use the gateway instead. Gateway knows who you are. So then all the API accesses have identity associated with them. All the API keys be withdrawn. So that you end up with a single point of observability, control, and access for your entire team. Plus engineers get onboarded faster because they can just tell their peers, just put your coding agent at the proxy, everything just works if you're on tail scale. Plus the security team say, great, we can get rid of all the security, all the API keys that are all over the place. We can just tell people, just go to HTTP. For us, it's HTTP colon slash AI. And then every API call has your identity associated with it. So you can just log everything. And so we use Aperture internally right now. ([Time 0:33:33](https://share.snipd.com/snip/68c4bc28-6440-4c97-9c59-c8fde86ac901)) - **Route Agents Through A Central Gateway** - To secure AI use, route coding agents through a gateway like Aperture so the gateway holds keys and attaches identity to every request. - This yields single-point observability, faster onboarding, and the ability to revoke or audit usage centrally. Transcript: David Carney I think we've got, I don't know how many tens of thousands API calls across a big part of the company at this point. We've just got every interaction with all of our coding agents going through Aperture right now internally. So we have full visibility into how people are using AI. All the requests, all the responses, the full logs. We're mining it for tool calls. And our security team gets to review it if they need to. And we're working with third-party providers to start doing analysis of the logs in real time and sort of after the fact. There's all this stuff that is unlocked for us. But initially it just started with the simple idea of we just want to solve the API key problem. And I'm meandering a little bit, but one of the reasons I love it so much is it builds so much on top of the fact that Tailscale makes things much easier because it takes identity and encryption. It brings them way down into the stack, like right at layer three. And if you do that, it can simplify so much stuff on top of it. And Aperture is just an example of that. Anybody can take TSNet and build an application that looks like a node in your network and you've got identity and connectivity and security baked in for free. ([Time 0:36:04](https://share.snipd.com/snip/cafe9c64-f628-4c0a-9aec-89a4429e95ee)) - **Aperture Alpha Is Free For Home Labs** - Aperture is in early alpha with a self-serve waitlist at aperture.tailscale and is free for home lab use. - Tailscale currently provisions hosted instances to scale safely but plans enterprise and self-hosted options later. Transcript: Adam Stacoviak A home lab, I'm thinking about having, is Aperture available to anyone? Is it a product? Do you have to pay for it? How do you deliver it to someone? David Carney I mean, it's an early alpha right now. There is a self-serve flow. We quietly launched it a couple of weeks ago. Adam Stacoviak It's not quiet now. David Carney Yeah, yeah, yeah. We did more of a push just the other day on it. But if you go to aperture.talescale you can sign up. We manage it as a wait list just because we don't want the service to get overloaded. But the idea is that we're going to open it up very quickly for everybody as soon as we're sure that things are just going to scale just fine. But basically, we will provision an instance. You authenticate it as a node into your network. It just shows up. You can start using it right away. It's in line with what we already do for Tailscale. It's free for home lab use. We're going to be announcing how we're bundling it as part of the free plan. Just free for home use, that kind of thing, just like we do. Obviously, we're planning on it being a paid product for enterprise, but we're still exploring pricing and all that there. ([Time 0:37:41](https://share.snipd.com/snip/3cbd409a-aae4-4a0d-b8d9-6e4d683adb87)) - **Hosted First To Move Fast Then Offer Self-Hosting** - Tailscale chose a hosted-first approach for Aperture to iterate quickly, gather product-market fit, and avoid version/deployment fragmentation. - Self-hosting remains a planned enterprise option once the product stabilizes. Transcript: David Carney Or liability. Adam Stacoviak Liability too. All the abilities, you know? Yeah. No, it's a very good question. David Carney Accountability, responsibility, liability, all those things. It's a very, very good question. And I agree with you. I think a lot of people will want and will expect to self-host it. And we do want to provide a path for that. So early, I get that. It's early and it's this little team of mine right now that built Aperture over the past few months, it's cliche, but we're operating very much like a startup. And it's like, well, we just need to choose one path and go really fast on that path. And it's like, what's the quickest way we can get feedback from customers, get people experimenting with it, getting to the point where we actually have traction. Do we have product-market fit? Is the fundamental question. Once you have more product-market fit, then we can start branching out into figuring out where that takes us. Frankly, internally, I also wanted to experiment. I think there is a world, to your point, I think data sovereignty and data governance is extremely important to people. But so is speed. I think there is a lot to be said for motions where it's like, oh no, we can, like Tailscale can help you provision instances. Maybe we hook into other cloud providers or maybe we get to the point where, I don't know, people could start sharing their infrastructure and to compute with other people. We can make it possible for people to, I don't know, create their own cloud providers or some kind of democratic cloud system using tailscale infrastructure. But I wanted to experiment with the idea of, well, what would it take? Or how much would customers resist a, I just want to launch an instance into my network right just make it easy for me like just give me a one click drop drop a note in right because there Are still the guarantee like we can't just simply start injecting nodes into customers networks like people have to authenticate them in so there's a lot of guarantees that we already Have in terms of our ability to just or the lack thereof to take over customers' networks. And I think a lot of customers just want the speed and convenience just to try something out. So we made a decision. It's working out really well so far. ([Time 0:42:22](https://share.snipd.com/snip/758bba1a-0c3f-4fd1-bda1-4a61128e4ce5)) - **Use TSNet And Multi Tailnet For Isolation** - Build TSNet apps to exploit identity+connectivity: examples include private AI gateways, isolated workload enclaves, and in-network services with ACLs. - Multi-Tailnet enables per-customer or per-workload isolation for safety and compliance. Transcript: David Carney We have a blog post or two about that, which is the ability for you to create multiple independent tailnets inside of your org or your team or your home. And there's API-only ones right now, which is basically for machine-to use cases. There's not a strong notion of user identity. And then there's ones that are more directly tied to the user identities. So we've got some customers that have a staging tailnet and a testing tailnet. And then user identity is a first-class thing. I believe those tracks of development will converge at some point. But there's already some really incredible stuff you can do with multi-tailnets, for instance. And that's one of the reasons I think things like Aperture and TSNet are so fascinating. In that I could create a separate tailnet and I could make sure that nothing can escape from that. And I can go off and do its thing and I can run coding agents in YOLO mode. I can have them connect to MCP servers and I have permissions that can fly around inside of the network and it's all nice and contained. And you can use Tailscale for that kind of thing. Those are the kinds of areas where I'm really excited for people to start experimenting with and bringing up ideas of just like, oh, if Tailscale did this for me or if it let me export this Kind of thing, or if it could transport this kind of policy, or if it could connect to these different things, then I could achieve X. And I want to hear more of those ideas so that we can start building more stuff and more features at the edge so that people can start using Tailscale more as a platform. ([Time 0:52:15](https://share.snipd.com/snip/ccada70a-74bd-4d55-8c1b-71c547faf2dd)) - **Segment Networks To Manage Agent Risk** - Enterprises face agent security and segmentation challenges; Tailscale enables decentralizing networks into smaller tailnets per workload to reduce risk. - Moving from one monolithic VPN to multiple tailnets simplifies isolation and governance. Transcript: David Carney One of the bigger issues that a lot of, especially larger companies that I've seen coming up more recently is they have a traditional network, traditional VPN. It's like one monolithic thing. And they're trying to bring up MCP servers, and they're trying to bring up MCP clients. And they've got these notions of, they basically are thinking like, oh, I've got now agents that are trying to operate inside of the network the same way humans used to. Except, well, I don't need to go on about the dangers of letting an agent run amok on an internal corporate network. But it's becoming, yeah, it's becoming obviously more and more an issue for especially bigger organizations that have traditionally dealt with security from a very centralized Monolithic perspective. So I think there's definitely been this push of just like, okay, well, how do we start segmenting or isolating or subdividing our network? How do we start decentralizing it more so that we can enable these different teams and pockets of the company to work more independently with each other or to work independently to solve Particular domain problems while still enabling the velocity and freedom of access to required information. So I think Tailscale is actually a way that companies can do that. I think there's lots of different approaches, but Tailscale definitely makes it easy. It's just like, okay, well instead of one gigantic monolithic network, maybe you start building one tail net per workload, for instance. And we've seen this kind of thing with people who are playing around with Kubernetes. And they have custom internal tooling that they need some kind of internal and monitoring system. It's like, oh no, when we bring up a cluster, we've got these applications that need to sit inside of it. It has to sort of moderate or govern certain kinds of networking access. We do a bunch of log analysis. Maybe we do a bunch of real-time stuff. How do we insert these applications that we've built into these networks in an isolated way? I think there's a lot of internal applications inside of companies that need to stay internal and private. Tailscale's good for that kind of thing. You can retrofit them inside of TSNet, and then you can encapsulate entire workloads inside of Tailnets themselves. ([Time 1:02:28](https://share.snipd.com/snip/21efd5c8-e297-4ae1-b007-8606ec855c80)) - **Combine Aperture With Real Time Policy Partners** - Integrate Aperture with third-party policy tools (e.g., Oso) to do real-time analysis and dynamically adjust security based on model/tool-call signals. - Use hooks to intercept tool calls and respond by throttling or auditing agents. Transcript: David Carney Could you block things? Yes. I mean, the short answer is yes. Something like an AI firewall, even, too. Adam Stacoviak That's why I think it's really interesting. You can do so much with this gateway. David Carney Yes, you can. We mentioned them in a blog post just the other day, but there's some integration partners. Oso is one, Servos is another. Yeah, I love Oso. They've been great to work with just over the past few weeks. We have an integration with them where we have an API, for instance, tool call hooks, they can intercept them and analyze those. And you can start to do things where you can dynamically adjust your network or your security policy based on effectively real-time signals. Adam Stacoviak Yeah, like activity. What's being called? What's being prompted? Is that what you mean by that like if if i'm trying to do not so much nefarious things but let's just say dangerous things yes i could be a new developer new builder uh or just maybe have ulterior David Carney Motives who knows what but like could you pay attention essentially and like yeah do different things and react yeah or you or you have or you have like an agent that is starting to get A little bit more fast and loose with the rules and starting to access things that maybe it shouldn't be yeah okay yeah and so there's there's there's ways um you know we can send signals Out to those tools and those tools have like their own kind of like i guess application level like network policy that can start to adapt in real time based on signals they're getting From Aperture because it's all centralized. So you can say, oh, this agent or this person or whatever, they're deviating a little bit off of the regular behavior. Maybe we should start locking down or auditing more and slowing down their interactions with these kinds of resources. ([Time 1:14:27](https://share.snipd.com/snip/2ac2d8e8-827c-48f8-bc6e-19e69c8fbbea)) - **Gateway Logs Create Prompt Session Provenance** - Aperture logs every stateless API call and can consolidate them into sessions so teams can review prompt histories, map code commits to sessions, and run post hoc investigations. - This creates provenance for legal, compliance, and learning purposes. Transcript: David Carney Yeah. Yeah. It is crazy, though, how fast those tools can let you move and the stuff they can do if left unchecked. You've got to be careful. I think, I guess, comments on a couple of things you just said. We've got some basic permissions with Aperture right now. Users can only see their own stuff, for instance. Admins can see the world. We've got a lot of stuff to implement there about, oh, maybe we only want a team to be able to see logs within their team. Maybe we only want a manager to see the team members. There's all these different kinds of access models that we need to explore with customers on this. And we are doing that. So there's a lot of room for new features there. But again, we're just trying to keep things simple at this point. One of the neat hacks that we've done internally, and I really like this one, is that you can actually point a coding agent, because we have an API. There's a whole bunch of endpoints inside of Aperture. And one of the endpoints inside of your tailwind is that you could actually get your own logs out of it. So you can point a coding agent and say, oh, I want you to explore basically how you've worked in the past. And so you can start to get these recursive learning or feedback loops with a coding agent reviewing how it's worked in the past or reviewing its previous logs. And I think there's a lot to unlock with that. We've just only started to scratch the surface. But it's yielded some really interesting insights for us as we've been digging into how do these protocols work, for instance. ([Time 1:21:52](https://share.snipd.com/snip/dc447ade-0a37-415a-855b-e124cfef3726)) - **Tailscale Is Enterprise Ready Not Just A VPN** - Common myths to debunk: Tailscale is not just a VPN or a hobbyist tool; it's enterprise-ready and emphasizes identity-first networking. - Tailscale will keep a free plan while expanding enterprise features and apps. Transcript: David Carney One of the myths is that we're just for home leverage or small teams. That's not true. We've got a significant number of enterprise customers. But I've often heard and called, or bump into people at conferences who were like, oh, so-and was saying that you're just for home labs or you're just for small teams, you're just a hobbyist Kind of thing. It's like, no, we're serious. Adam Stacoviak You have some of the most advanced engineers I've ever known of. You've got some really talented people in your team. I'm very fortunate. I know you agree with that. You really do. You have some serious engineering talent. Yeah, we do. I'm very grateful for that. It's an incredible team. Brad Fitzpatrick is one of the ones I'm thinking of. He's been on our podcast, GoTime. We used to host this podcast called GoTime. That's why I'm so emphatic about GopherCon even too and Go the Language. And Brad's been on that podcast. And I think, I'm not sure who all is still there over all these years, but a lot of folks that I've just paid attention to and have leaned on for wisdom on how to morally navigate the software We're building, even from a technical level, just bar none. Some really awesome people there. David Carney Yeah, yeah. I count my blessings with the team we have. But yeah, to talk about the myths, we're never going to give up having a free plan. Free forever. Yeah, free forever. We're always going to have something, and we're going to be pushing more and more into that over time. That's really important to Avery and me and so many other members of Tailscale in general. But we are building more and more stuff all the time, and a lot of that has enabled us to just take on bigger and bigger and bigger customers to help, frankly, pay the bills and help us grow And help us expand. It just makes TailScale a better product for everyone. We are definitely enterprise ready. That has been one of the myths that over the past couple of years we've done a lot to establish that, but there's always more I think we could do because we've come bottom up. There's always that. People who learn about you in the early days, that's how they think about you. It's like the curse of SaaS. Once somebody adopts you, you have to spend so much time re-educating them because the products change and evolve a lot. ([Time 1:30:35](https://share.snipd.com/snip/ce1d2915-1912-4cef-b998-c74480ca8a9a))