Tailscale Unveils Aperture Gateway to Break AI Vendor Lock-In
Ai4
Decoupling models from interfaces and sandboxes through identity-based network gateways lowers switching costs and prevents single-vendor dependency as AI runtimes evolve.
## Background
Published by Ai4 on YouTube on August 14, 2026, this talk features Remy Guercio, Strategic Projects lead at Tailscale. The session examines the hidden infrastructure tax that impedes enterprise AI adoption—such as exposed endpoints and overprivileged systems—and demonstrates how identity-based connectivity enables safe, private, and rapid deployment of AI into production workflows.
## TL;DR
The presentation traces the shift from unconstrained 'token maxing' to 'ROI maxing,' highlighting common pitfalls such as restrictive vendor consolidation by management and fragile, micro-token optimizations by engineers. Guercio advocates for decoupling internal AI systems into four distinct pillars: the LLM layer, data connectors, user interfaces, and execution sandboxes. By leveraging Tailscale Aperture and identity-based mesh networking through tsnet, organizations can eliminate API key sprawl, establish unified governance across model and data endpoints, and swap underlying models or agent sandboxes without incurring punitive switching costs.
## Atmosphere & style
The delivery is pragmatic, grounded, and architectural, cutting cleanly through the prevailing industry hype around foundation models to focus on operational reality. Guercio presents with calm, authoritative clarity, systematically analyzing developer and executive missteps with empathetic candor. The session feels like an insider systems engineering post-mortem, transforming abstract anxieties about AI sprawl and spiraling compute costs into an actionable blueprint for network-level governance.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) The AI industry has evolved from basic autocomplete plugins into autonomous agentic workflows driven by token maxing, massive context windows, and protocols like MCP.
- [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) Token maxing and vertically integrated AI stacks create significant compute expenses and trap organizations into rigid vendor lock-in.
- [04:05](https://www.youtube.com/watch?v=CXaFzIVqyes&t=245s) Executive vendor consolidation risks committing to a single provider right before competing models leap ahead, sacrificing architectural agility.
- [04:05](https://www.youtube.com/watch?v=CXaFzIVqyes&t=245s) Premature micro-optimizations by engineers often backfire by breaking prompt caching and adding fragile layers that quickly become obsolete.
- [07:07](https://www.youtube.com/watch?v=CXaFzIVqyes&t=427s) Achieving true AI ROI requires decoupling internal architecture into four distinct components: the LLM layer, data connectors, user interfaces, and execution sandboxes.
- [09:44](https://www.youtube.com/watch?v=CXaFzIVqyes&t=584s) Traditional AI gateways provide visibility into usage and costs, but they introduce severe credential sprawl when distributing API keys across large organizations.
- [09:44](https://www.youtube.com/watch?v=CXaFzIVqyes&t=584s) Tailscale Aperture replaces static API keys with identity-based mesh networking, granting zero-key model access based on machine and user identity via tsnet.
- [14:48](https://www.youtube.com/watch?v=CXaFzIVqyes&t=888s) Consolidating both model access and internal tool data access into a single identity-driven control plane enables comprehensive auditability and granular permission policies.
- [15:17](https://www.youtube.com/watch?v=CXaFzIVqyes&t=917s) Frontier AI labs bundle user interfaces with proprietary models to protect profit margins as raw compute costs trend downward.
- [15:17](https://www.youtube.com/watch?v=CXaFzIVqyes&t=917s) Layering custom internal front-ends over an AI gateway insulates teams from upstream vendor changes and prevents costly company-wide retraining.
- [16:39](https://www.youtube.com/watch?v=CXaFzIVqyes&t=999s) Agent sandbox runtimes evolve even faster than foundation models, requiring execution-agnostic networking to avoid infrastructure lock-in.
- [16:39](https://www.youtube.com/watch?v=CXaFzIVqyes&t=999s) Maximizing AI return on investment fundamentally depends on maintaining modularity and choice across every layer of the infrastructure stack.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) From Token Maxing to Agentic Coding: The Last 12 Months in AI
The AI landscape over the past 12 to 18 months has been defined by an aggressive push to push model capabilities to their absolute limits—a trend frequently referred to as "token maxing." While the term often carries a pejorative connotation, it accurately describes the industry-wide experiment of asking what happens when you throw every possible resource at AI. This era kicked off with the introduction of million-token context windows, granting models the capacity to ingest, reason over, and analyze massive volumes of unstructured information all at once.
Following expanded context windows, the Model Context Protocol (MCP) emerged seemingly overnight, shifting from an unknown concept to an ubiquitous standard for piping corporate data, emails, and internal systems directly into the model's context. In parallel, development workflows transformed as coding tools evolved to autonomously traverse local file trees and pull context straight from the CLI. Together, these advancements sparked the transition from basic AI-assisted search and simple autocomplete plugins to fully agentic workflows, where a developer can give a complex prompt, hope the system avoids errors, step away, and return to completed work.
```
+-------------------------------------------------------------------+
| Token Maxing |
| |
| 1M+ Context Windows + Model Context Protocol (MCP) + CLI |
| (Massive compute) (Corporate data & APIs) (Local files)
+---------------------------------+---------------------------------+
|
v
+-------------------------------------------------------------------+
| Agentic Coding |
| From: Autocomplete & partial file edits |
| To: Autonomous execution across multi-file codebases |
+-------------------------------------------------------------------+
```
- **Million-token context windows** allowed LLMs to ingest and reason over immense amounts of data simultaneously.
- **Model Context Protocol (MCP)** provided standardized connectors for business data, calendars, and communications.
- **Agentic coding** transitioned from inline IDE auto-complete into autonomous agents capable of gathering context and editing projects independently.
---
[02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) The Hidden Costs and Lock-in of Token Maxing
Despite making previously impossible workflows viable, token maxing introduces severe financial and architectural drawbacks. Running large-scale models across massive context windows is exceptionally costly, and the design patterns underpinning early MCP implementations and visual user interfaces have actively encouraged token waste. Systems routinely instruct users and agents to dump raw data into prompts under the assumption that background context compaction will resolve inefficiencies, leaving organizations to wonder what value was actually delivered relative to the bill.
At the same time, the tooling ecosystem has fractured into tightly coupled, vertically integrated stacks. High-profile proprietary tools like Claude Code and OpenAI Codex, alongside open alternatives like OpenCode and Pi, frequently bind users to a single interface, a single provider, and a single underlying model family. When teams adopt these integrated silos, they forfeit the flexibility to swap components as the model landscape evolves.
- Context windows running at peak capacity generate steep operational and compute expenses.
- Default interface and MCP patterns incentivize over-stuffing prompts rather than curating precise context.
- Vertically integrated stacks lock organizations into rigid model-provider-interface pipelines.
---
[04:05](https://www.youtube.com/watch?v=CXaFzIVqyes&t=245s) The Two Failure Modes in AI Cost Optimization
When organizations attempt to rein in spiraling AI expenses, they routinely fall into one of two common failure modes depending on whether the decision is driven by management or individual contributors.
The business-level failure mode occurs when directors or managers review quarterly invoices and discover redundant, expensive subscriptions across OpenAI, Anthropic, Google Gemini, and various self-hosted open-weight models. The instinctive executive response is vendor consolidation—attempting to lock the entire company into a single provider to secure bulk discounts and visibility. However, committing exclusively to a single vendor for an annual cycle is perilous; an organization that went all-in on Anthropic and Claude Code three months prior might find itself trailing when OpenAI or open-source foundation models suddenly leap ahead.
```
AI Cost Traps
|
+-------------------------+-------------------------+
| |
v v
[Management Trap] [IC Trap]
Vendor Consolidation Premature Optimization
- Locks company to one vendor - Saves ~5% tokens via tricks
- Outpaced when competitors leap - Destroys prompt cache benefits
- Sacrifices architectural agility - Fragile, non-deterministic layers
```
The individual contributor (IC) failure mode leans into premature optimization. Engineers often introduce complex middleware, compression algorithms, or prompt-stripping libraries designed to shave 5% off the context window. These micro-optimizations rarely deliver meaningful business savings and frequently carry hidden trade-offs: they can invalidate prompt caching (converting cheap cached tokens into expensive dynamic tokens) or stack non-deterministic compression on top of non-deterministic models. Once a new model generation is released, these bespoke optimization layers inevitably become obsolete.
---
[07:07](https://www.youtube.com/watch?v=CXaFzIVqyes&t=427s) ROI Maxing and the Four Core Components of Internal AI
The industry is entering a transitional phase from "token maxing" to "ROI maxing," shifting focus from raw capability consumption to maximizing tangible business return on AI deployments. Achieving ROI maxing requires organizations to minimize the marginal switching cost of changing any part of their AI architecture at any moment.
To maintain architectural agility, internal AI deployments must be broken down into four distinct, decoupled components:
1. **The LLM Layer:** The underlying compute engine, encompassing closed foundation models and self-hosted open models.
2. **Data Connectors:** The ingestion pipelines bringing internal content to models via MCP, standard REST APIs, or local command-line utilities.
3. **The Interface:** The user interaction surface, which should remain decoupled from the underlying model (e.g., custom enterprise chat clients, Slack bot agents, or developer environments).
4. **Sandboxes and Environments:** The runtime infrastructure where autonomous agents safely execute code and interface with internal tools.
Decoupling these four pillars prevents monolithic vendor lock-in. When components are isolated, swapping an underlying model or adding an internal data source does not require re-architecting the entire system.
---
[09:44](https://www.youtube.com/watch?v=CXaFzIVqyes&t=584s) Decoupling the Stack with Tailscale Aperture and Identity-Based Connectivity
An AI gateway provides the architectural control plane necessary to decouple models, interfaces, and data sources while giving administrators complete visibility into usage, token spend, model distribution, and average costs across both human users and automated agents. However, conventional gateway deployments suffer from API key sprawl. In typical setups, administrators store provider credentials inside the gateway and then issue hundreds of secondary gateway API keys across engineering teams and internal services—an approach that falls apart when scaling access to non-technical employees.
```
+-------------------+ Tailscale Mesh Network +-------------------+
| Human / Agent | (Identity verified via tsnet) | Tailscale Aperture|
| Device / Sandbox |====================================>| AI Gateway |
+-------------------+ +---------+---------+
|
+---------------------------+---------------------------+
| | |
v v v
+---------------+ +---------------+ +---------------+
| OpenAI Models | | Anthropic LLMs| | Open / Local |
+---------------+ +---------------+ +---------------+
```
Tailscale addresses this credential bottleneck in its AI gateway, Aperture, by anchoring access directly to network identity rather than static tokens:
- **Identity-Based Mesh Networking:** Built directly on Tailscale's overlay network, Aperture can communicate with laptops, mobile devices, remote sandboxes, or bare-metal edge environments.
- **Embedded Identity with `tsnet`:** Using the open-source `tsnet` Go library, Aperture inspects the cryptographic machine and human identity attached to incoming network requests over the mesh.
- **Zero-Key Access Control:** Administrators configure granular access rules, routing cheap or open models to broad internal teams while reserving frontier models for specialized use cases, all routed through a single endpoint without distributing API keys.
- **Decoupled Data and MCP Tooling:** Identity-driven connectivity eliminates the friction of requiring users and agents to re-authenticate across disparate external tools each time a new model or interface is tested.
[14:48](https://www.youtube.com/watch?v=CXaFzIVqyes&t=888s) Unified Access Control: Consolidating Data and Model Endpoints
By routing traffic through a centralized gateway, organizations can bridge the gap between user identity, model access, and internal tool authorization. Instead of juggling disparate credentials, tokens, and firewall rules across dozens of internal microservices, end users authenticate directly into the gateway. From there, administrators can apply the exact same identity-based access control rules used for LLMs to backend tools and APIs. This creates a dual-pillar control plane: one governed endpoint managing all data access, and another managing all LLM interactions.
This consolidation gives platform and security teams total visibility over who is making requests, which models are being queried, and which internal endpoints are returning enterprise data. Rather than dealing with fragmented permissions that proliferate across different teams, administrators can define granular policies—determining explicitly, "You get access to these tools or you get access to these endpoints"—and distribute those capabilities safely across the company.
```
+-------------------------------------------------+
| Tailscale Aperture |
| +--------------------+ +-------------------+ |
User ->| | Model Access Plane | | Data Access Plane | |-> Tools & Data
| +--------------------+ +-------------------+ |
| Unified Identity & Policy Controls |
+-------------------------------------------------+
```
- Consolidating identity at the gateway replaces sprawling, bespoke API keys with a centralized policy engine.
- A unified architecture provides full auditability across both model queries and internal data tool invocations.
---
[15:17](https://www.youtube.com/watch?v=CXaFzIVqyes&t=917s) Decoupling the Interface: Building Custom UIs over an AI Gateway
The user interface layer in modern enterprise AI is typically tightly bundled with proprietary models—a dynamic driven largely by the AI frontier labs. As open-weight models push inference costs down and erode pure compute margins, model providers increasingly try to own the full application stack to capture higher profits. However, tightly coupling an organization's workflow to a third-party vendor's UI creates severe organizational friction. If a team builds their daily routines around a provider interface like Claude, switching to a more cost-effective or capable alternative later requires retraining the entire company on an unfamiliar interface.
To demonstrate how to break this dependency, Tailscale built their own internal chat interface layered directly on top of Aperture, their AI gateway. This custom UI serves as a blueprint rather than a mandatory off-the-shelf product, proving that teams can leverage gateway identity controls to power bespoke front-ends for internal groups like customer support or customer success. By owning the UI layer through standard gateway endpoints, organizations retain complete freedom underneath: models, prompt routing, and data retrievals can be swapped out transparently without disrupting end-user workflows or forcing employees to relearn their tools.
- AI labs attempt to own the interface to protect profit margins as open-source models drive inference costs downward.
- Gateway-backed custom front-ends insulate teams like customer support from upstream vendor changes, letting infrastructure teams swap underlying LLMs without triggering company-wide retraining.
---
[16:39](https://www.youtube.com/watch?v=CXaFzIVqyes&t=999s) Sandboxes, Agent Runtimes, and Maximizing ROI by Eliminating Lock-In
While the foundation model landscape evolves rapidly, the sandbox runtime environment for autonomous agents is moving at an even faster pace. New platforms, execution engines, and runtime optimizations emerge continuously, with vendor rankings for the lowest cold-start latencies and fastest execution speeds shifting on a monthly basis. Because no single provider holds a permanent advantage, tying agent architectures to a specific proprietary sandbox runtime introduces significant technical debt and risk.
In their demonstration environment, Tailscale runs autonomous agents inside Vercel sandboxes, but the underlying system is agnostic. Teams can deploy code execution agents across Vercel, isolated virtual machines, or any preferred sandbox environment, wiring them securely back into Aperture or another gateway via Tailscale's identity-aware mesh. Combining connectivity and access control into a single layer ensures that changing an execution runtime is as frictionless as changing a model provider.
Ultimately, true "ROI maxing is maximizing choice, right, to prevent lock-in." When infrastructure is architected around an identity-first gateway from the outset, companies can navigate the rapid twists of the AI ecosystem incrementally, adopting the best models and runtimes available without facing prohibitive switching costs.
- Sandboxes and code execution environments evolve faster than LLMs, with benchmarks for speed and cold-start times fluctuating constantly.
- Decoupling execution environments through identity-based connectivity lets teams use Vercel sandboxes or alternative runtimes interchangeably.
- Long-term AI ROI depends on upfront architectural flexibility that allows teams to make modular, cost-effective decisions at every step of the stack.
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) The AI landscape over the past 12 to 18 months has been defined by an aggressive push to push model capabilities to their absolute limits—a trend frequently referred to as 'token maxing.' — Remy Guercio
> [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) When teams adopt these integrated silos, they forfeit the flexibility to swap components as the model landscape evolves. — Remy Guercio
> [04:05](https://www.youtube.com/watch?v=CXaFzIVqyes&t=245s) The business-level failure mode occurs when directors or managers review quarterly invoices and discover redundant, expensive subscriptions across OpenAI, Anthropic, Google Gemini, and various self-hosted open-weight models. — Remy Guercio
> [07:07](https://www.youtube.com/watch?v=CXaFzIVqyes&t=427s) The industry is entering a transitional phase from 'token maxing' to 'ROI maxing,' shifting focus from raw capability consumption to maximizing tangible business return on AI deployments. — Remy Guercio
> [07:07](https://www.youtube.com/watch?v=CXaFzIVqyes&t=427s) Achieving ROI maxing requires organizations to minimize the marginal switching cost of changing any part of their AI architecture at any moment. — Remy Guercio
> [09:44](https://www.youtube.com/watch?v=CXaFzIVqyes&t=584s) Tailscale addresses this credential bottleneck in its AI gateway, Aperture, by anchoring access directly to network identity rather than static tokens — Remy Guercio
> [14:48](https://www.youtube.com/watch?v=CXaFzIVqyes&t=888s) You get access to these tools or you get access to these endpoints — Remy Guercio
> [15:17](https://www.youtube.com/watch?v=CXaFzIVqyes&t=917s) If a team builds their daily routines around a provider interface like Claude, switching to a more cost-effective or capable alternative later requires retraining the entire company on an unfamiliar interface. — Remy Guercio
> [16:39](https://www.youtube.com/watch?v=CXaFzIVqyes&t=999s) ROI maxing is maximizing choice, right, to prevent lock-in. — Remy Guercio
> [16:39](https://www.youtube.com/watch?v=CXaFzIVqyes&t=999s) When infrastructure is architected around an identity-first gateway from the outset, companies can navigate the rapid twists of the AI ecosystem incrementally, adopting the best models and runtimes available without facing prohibitive switching costs. — Remy Guercio
## Mentioned
Remy Guercio, Tailscale, Tailscale Aperture, tsnet, Model Context Protocol (MCP), OpenAI, OpenAI Codex, Anthropic, Claude, Claude Code, Google Gemini, OpenCode, Pi, Vercel, Slack, Go
## Video description
Remy Guercio - Strategic Projects, Tailscale
What if the biggest barrier to successful AI adoption isn’t your model but the infrastructure around it?
Most companies are not trying to train their own models. They are trying to integrate AI into real products, workflows, and internal systems. The real challenge appears after the prototype works and teams try to safely connect AI to production data, internal APIs, and the services that power their applications.
Suddenly what looked like a fast path to value turns into months of networking changes, security reviews, and fragile infrastructure. This talk explores the hidden infrastructure tax that slows AI adoption through exposed endpoints, complex connectivity between services, and overprivileged systems.
I will show how identity based connectivity simplifies AI architecture, keeps services private, and enforces granular access across people, applications, and AI agents.
The result is faster time to production, stronger governance over AI enabled systems, and the ability to safely connect AI into existing products without exposing critical infrastructure. If your organization is trying to turn AI adoption into real business value, this session shows why solving connectivity is one of the fastest ways to move forward.
Tailscale argues that achieving meaningful enterprise AI return on investment requires transitioning from unconstrained "token maxing" to a decoupled, modular architecture. According to the presentation, anchoring model routing, internal data access, and agent execution sandboxes to cryptographic network identity eliminates vendor lock-in and administrative credential sprawl.
The Inefficiencies and Traps of Token Maxing (2:45)
The rapid expansion of large language models to million-token context windows alongside protocols like the Model Context Protocol (MCP) enabled fully agentic coding across multi-file codebases. However, this era of "token maxing" introduced steep computational expenses and architectural lock-in. Default interface patterns and early MCP implementations routinely encouraged dumping raw, uncurated data into prompts under the assumption that background compaction would resolve inefficiencies, binding organizations to tightly integrated vertical silos like Claude Code or OpenAI Codex.
When organizations attempt to curb these expenses, they frequently fall into two common traps. In the management trap, executives pursue vendor consolidation, locking the enterprise into single-vendor annual commitments for bulk discounts, only to fall behind when competing foundation models leap ahead. In the individual contributor trap, engineers implement fragile compression middleware to shave roughly 5% off context windows, inadvertently breaking prompt caching benefits and creating maintenance debt that becomes obsolete with the next model release.
Decoupling the Enterprise AI Architecture (7:07)
To transition toward "ROI maxing," the presentation contends that organizations must minimize the marginal switching cost of changing any part of their AI architecture. Maintaining agility requires breaking internal AI deployments into four decoupled layers: the LLM layer (covering open and closed foundation models), data connectors (MCP, standard REST APIs, and CLI tools), interfaces (custom UIs and Slack bots), and sandboxes (runtime execution environments for autonomous agents).
Separating these four pillars ensures that changes in one component do not demand a complete system redesign. When data connectors and interfaces operate independently from the compute engine, infrastructure teams can transparently swap out underlying models or adopt cheaper open-weight alternatives without breaking workflows or rewriting integration logic.
Identity-Based Connectivity Replaces API Key Sprawl (9:44)
While centralized AI gateways provide necessary auditability over token spend and model usage, standard implementations suffer from API key sprawl. Storing vendor credentials in a gateway typically requires distributing hundreds of secondary API keys across internal teams and services, an approach that breaks down when scaling to non-technical staff. Tailscale addresses this by embedding its AI gateway, Aperture, directly into an overlay mesh network.
Using the open-source tsnet library, the gateway verifies the cryptographic human or machine identity attached to incoming network requests. This enables zero-key access control, allowing administrators to route cheaper models to general internal users while restricting frontier models to specialized tasks. By applying the same identity controls to both LLM endpoints and internal data APIs, security teams gain unified visibility over which identities access enterprise tools and data without managing fragmented firewall rules.
Preserving Flexibility Across Interfaces and Sandboxes (15:17)
Vendor lock-in equally affects interfaces and execution runtimes. Frontier AI labs frequently couple user interfaces directly with proprietary models to protect profit margins against declining inference costs. However, depending on vendor-owned UIs exposes organizations to retraining friction whenever underlying models change. Tailscale illustrates that deploying custom internal front-ends over a gateway allows teams like customer support to maintain consistent workflows while infrastructure operators swap models behind the scenes.
Simultaneously, autonomous agent execution runtimes—such as Vercel sandboxes or isolated virtual machines—evolve faster than foundation models, with cold-start speeds and performance benchmarks shifting monthly. Anchoring execution runtimes into a private identity mesh allows organizations to swap sandbox providers interchangeably, ensuring that the runtime environment does not become an architectural bottleneck.
The presentation concludes that sustained AI ROI depends on upfront architectural flexibility that preserves the freedom to swap models, runtimes, and tools without prohibitive switching costs. However, shifting to an identity-first gateway architecture assumes an organization possesses the platform engineering maturity to build internal interfaces and maintain centralized governance policies.
精炼阅读摘要
Tailscale 认为，企业 AI 正在从盲目堆叠上下文与算力的“Token Maxing”阶段，转向追求实际业务回报的“ROI Maxing”阶段；唯有将模型、数据连接器、界面与执行沙箱四层架构彻底解耦，并依托基于网络身份的网关实施治理，企业才能摆脱专有厂商锁定并实现真正的投资回报率。
“Token Maxing”的成本陷阱与治理误区 (2:45)
过去一年多来，百万级 Token 上下文窗口与模型上下文协议（MCP）的迅速普及，推动了从简单代码补全向自主智能体（Agent）多文件协作的跨越。然而，这种无限制调用资源的“Token Maxing”模式也带来了严重的财务与架构弊端：默认的用户界面和 MCP 规范往往鼓励将海量未经筛选的原始数据直接填入提示词，造成计算成本飙升，同时垂直集成的专有工具链也将企业限制在单一模型与供应商生态中。
在应对失控的 AI 账单时，组织通常会陷入两类失效陷阱：管理层往往倾向于粗暴地推行“供应商整合”，试图通过锁定单一厂商的年度合约来获取折扣，但一旦竞争对手技术突飞猛进，企业便会失去调整空间而陷入落后；而工程师团队则容易陷入过早微调的误区，花费精力编写复杂的中间件来削减 5% 的 Token，这不仅会破坏提示词缓存机制、增加非确定性风险，还会随着新一代基础模型的推出而迅速贬值为无用技术债务。
AI 架构四层解耦与最大化转换灵活性 (7:07)
针对成本与锁定困境，演讲提出应当转向“ROI Maxing”，其核心原则在于将架构中任何组件的边际替换成本降至最低。为此，企业必须将内部 AI 部署拆解为四个相互独立的解耦层级：负责底层计算引擎的 LLM 层、通过 MCP 或 API 汇聚企业内部内容的数据连接器、面向终端用户的交互界面，以及供智能体安全执行代码的沙箱环境。
这种解耦能够有效打破单一厂商的垄断闭环。各组件彼此独立后，基础设施团队无论是引入开源大模型替代闭源商业模型，还是接入新的业务数据源，都无需重构整个系统，从而使企业在技术快速迭代时能够随时随地进行模块化替换。
以网络身份替代静态密钥的网关控制面 (9:44)
AI 网关能够为解耦架构提供必要的控制平面，集中统计用量、成本与模型分布，但传统的网关方案往往受困于 API 密钥的肆意扩散——向多团队和非技术人员层层分发二级密钥会导致严重的安全与运维瓶颈。Tailscale 提出的 Aperture 网关方案将访问控制直接锚定在覆盖网络（Overlay Network）的机器与用户身份上，利用开源库 tsnet 验证传入网络流量的加密身份，从而实现无密钥（Zero-Key）的分级访问。
通过该网关，企业构建起了统一的双支柱治理平面：一个控制面负责模型的按需路由（如向广泛员工开放低成本模型，将前沿模型保留给特定业务），另一个控制面管理后端企业工具与 MCP 数据的访问授权。安全与平台团队得以对“谁发起了请求”、“调用了哪个模型”以及“读取了哪些内部端点”拥有端到端的全面审计能力，消除了各微服务间割裂的认证体系与防火墙策略。
独立交互界面与动态沙箱运行时的选择权 (15:17)
演讲指出，随着开源权重模型压低纯计算利润，前沿模型实验室正加速将其产品与专有用户界面深度绑定。然而，若企业工作流直接建立在第三方供应商的界面（如 Claude 交互面板）之上，未来切换底层模型就必须强制全员重新培训。Tailscale 通过在 Aperture 网关上搭建内部聊天界面作为示范，证明企业若能自主掌控面向业务部门的前端，基础设施团队即可在底层静默切换模型路由与检索逻辑，而完全不破坏终端用户的使用习惯。
此外，智能体代码执行沙箱的技术演进速度甚至超越了大语言模型本身，各家服务在启动延迟与执行速度上的优劣每月都在变动。通过身份感知网络将 Vercel 沙箱或独立虚拟机安全连回网关，团队即可随意更换底层执行环境。演讲总结指出，最大化商业回报的真谛在于保留选择权，依托以身份为核心的网关消除专有绑定，才能在长期的 AI 竞赛中守住架构主动权。
该方案主张以网络身份网关和四层解耦打破 AI 厂商的垂直锁定，为企业灵活迁移技术栈提供了清晰路径；然而，企业自建交互界面与维护身份驱动网关同样会产生内部工程与运维开销，组织在推行此方案时仍需在自研平台成本与外购一体化工具的便利性之间权衡考量。
Detailed notes — zh
## Background
本视频由频道 Ai4 于 2026 年 8 月 14 日发布在 YouTube 平台，由 Tailscale 战略项目负责人 Remy Guercio 主讲。视频简介指出，企业 AI 落地的最大瓶颈往往不在于模型本身，而在于连接生产数据、API 与服务的复杂基础设施税，本演讲旨在探讨如何通过基于身份的网络连接与 AI 网关简化架构，安全解锁 AI 的真实投资回报率（ROI）。
## TL;DR
演讲指出 AI 行业正在从盲目堆砌上下文与算力消耗的“Token Maxing”时代，迈向注重实际商业价值与成本效益的“ROI Maxing”阶段。企业在提升 AI 效益时常踩入“管理层一刀切整合供应商”与“工程师过早微调压缩 Token”两大误区，导致陷入供应商锁定或系统不稳定。为此，企业应将内部 AI 架构解耦为 LLM 计算层、数据连接器（MCP）、交互界面与执行沙箱四大核心组件。通过引入 AI 网关并结合 Tailscale 基于身份的原生网状网络（tsnet），组织能够彻底摒弃繁琐的 API Key 分发，实现对人类与 Agent 的细粒度权限管控，从而大幅降低架构切换的边际成本并最大化长期选择权。
## Atmosphere & style
整场演讲呈现出务实、清醒且极具前瞻性的技术洞察风格，节奏紧凑且论证层层递进。主讲人以从容沉稳的语调剖析了行业对大上下文与垂直工具链狂热背后的隐性成本危机，随后以清晰的系统架构图引导听众思考底层解耦的本质。整体氛围兼具硬核工程深度与敏锐的商业现实考量，为深陷大模型选型与基础设施管理焦虑的技术管理者提供了一套清晰笃定的落地方案。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) 过去 12 到 18 个月 AI 领域经历了“Token Maxing”狂潮，由百万级上下文窗口、MCP 协议与基于 CLI 的智能体编程工具共同推动范式演进。
- [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) “Token Maxing”带来了高额算力成本账单，且现存工具链机制容易诱导滥用 Token 并造成高度垂直整合的供应商锁定。
- [04:19](https://www.youtube.com/watch?v=CXaFzIVqyes&t=259s) 企业提升 AI 投资回报率时常陷入两大失败模式：管理层的一刀切供应商整合，以及一线工程师缺乏实际成效的过早优化。
- [07:12](https://www.youtube.com/watch?v=CXaFzIVqyes&t=432s) 未来行业将转向“ROI Maxing”，解耦的企业内部 AI 架构由四大核心组件构成：LLM 计算层、数据连接器、交互界面与执行沙箱。
- [09:01](https://www.youtube.com/watch?v=CXaFzIVqyes&t=541s) 通过部署 AI 网关（AI Gateway）实现堆栈解耦，能够降低技术选择与组件切换的边际成本，并提供全局可见的使用量与成本看板。
- [10:54](https://www.youtube.com/watch?v=CXaFzIVqyes&t=654s) Tailscale 网关项目 Aperture 摒弃了传统的内部 API Key 分发，直接利用 Tailscale 网络与 tsnet 库将网络连接身份作为权限校验依据。
- [10:54](https://www.youtube.com/watch?v=CXaFzIVqyes&t=654s) 在网络覆盖层中原生区分人类身份与机器身份，实现了免密鉴权以及面向不同主体的细粒度访问策略与配额管理。
- [13:00](https://www.youtube.com/watch?v=CXaFzIVqyes&t=780s) 在模型与数据层（MCP），统一网关能够收敛多厂商 API 密钥并简化单点认证，避免跨外部工具反复登录配置的高摩擦力。
- [13:00](https://www.youtube.com/watch?v=CXaFzIVqyes&t=780s) 在界面与沙箱层，统一网关支持按业务场景定制独立 UI，并使 AI Agent 能够敏捷适配底层高频迭代的多种沙箱运行时。
- [17:46](https://www.youtube.com/watch?v=CXaFzIVqyes&t=1066s) 实现 AI 投资回报率最大化的核心在于通过基于身份的安全连接架构最大化选择权，消除重构成本以防供应商锁定。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) 从“Token Maxing”到智能体编程的爆发
Tailscale 战略项目负责人 Remy Guercio 开场介绍了自己在 Tailscale 内部专注于 AI Gateway 及各类 AI 赋能项目的工作背景。本次演讲的核心议题聚焦于网络连接性（Connectivity）与身份认证（Identity）如何真正解锁企业内部 AI 的投资回报率（ROI）。在深入探讨 ROI 之前，Remy 首先带观众回顾了过去 12 到 18 个月 AI 领域的发展狂潮。他提出了一个核心词汇——“Token Maxing”（Token 极限化/算力拉满）。虽然这个词在极客圈子里有时略带贬义，但在过去一年多的技术语境中，它代表了整个行业都在探索如何将 AI 和 Token 的能力压榨到极致：只要把所有能拿到的东西统统扔给大模型，究竟能做成什么？
这一阶段的技术演进主要由三股力量共同推动：
1. **百万级上下文窗口（Million-token Context Windows）**：一年前各大模型厂商相继推出了前所未有的超大上下文窗口，赋予了模型一次性推理和处理海量数据的能力。
2. **MCP（Model Context Protocol）的瞬时爆发**：MCP 从名不见经传到迅速席卷整个行业，其本质就是为了配合超大上下文窗口，“尽可能把能搜集到的企业数据统统塞进 Context 里”，打通邮件、文档以及各类异构数据源。
3. **基于 CLI 的智能体编程工具（Agentic Coding Tools）**：编码工具在跨本地文件查找上下文、精准切分代码片段并整合成上下文的能力上迎来了质的飞跃。
得益于这三者的结合，编程范式发生了根本性转变：从最初简单的“代码搜索引擎”或 VS Code 插件式的“智能补全（Autocomplete）”，跃升为真正的智能体编程——开发者只需向 AI 下达一个任务，嘱咐一句“请千万别犯错”，就能直接起身离开工位，稍后回来查看完整成果，让 AI 独立完成以往根本无法实现的复杂工程。
```mermaid
flowchart TD
accTitle: Token Maxing 驱动的智能体编程演进流程
subgraph ContextExpansion["上下文能力扩容 (Token Maxing)"]
A["1M+ 超大上下文窗口"]
B["MCP 协议全量导入企业数据"]
C["CLI 工具本地多文件智能检索"]
end
subgraph AgenticEvolution["编码范式演进"]
D["早期形态: 搜索问答与单行 AutoComplete"]
E["局部增强: 单文件/局部片段辅助生成"]
F["智能体编程: 全自主下发任务与异步交付"]
end
ContextExpansion --> AgenticEvolution
```
---
### [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) Token 浪费与垂直工具链的供应商锁定
尽管“Token Maxing”使以往不可思议的任务成为现实，但它也带来了显而易见的现实阵痛。最直接的痛点在于高昂的账单开销：超大上下文窗口下的模型调用极其昂贵。更糟糕的是，现有的许多 UI 交互工具以及 MCP 的原始设计，在默认机制上就在变相鼓励浪费 Token——系统不断诱导用户“尽管往里面塞数据，反正我们会做上下文压缩”。最终虽然任务完成了，但企业往往要承担不成比例的高昂算力成本。
另一个严重问题是工具链发展的不均衡与深度捆绑。无论是 Anthropic 推出的 Claude Code、OpenAI 相关的 Codex，还是社区开源的 OpenCode 和 Pi 等工具，市场上逐渐形成了高度垂直整合的封闭技术栈（Vertically Integrated Toolchains）。企业一旦采用某种方案，往往就会被锁死在“单一模型 + 单一服务商 + 单一前端界面”的死胡同里，丧失了灵活切换与混合编排的能力。
- **超大上下文的高额开销**：上下文调用量与费用呈正比，缺乏约束的输入让企业账单迅速膨胀。
- **机制鼓励浪费**：工具链默认堆砌无用上下文，形成“先肆意塞入、再粗暴压缩”的不良工程习惯。
- **技术栈硬锁定（Vendor Lock-in）**：从底层大模型、API 提供商到上层交互界面被深度绑定，难以根据业务发展灵活解耦。
---
### [04:19](https://www.youtube.com/watch?v=CXaFzIVqyes&t=259s) 提升 AI 投资回报率的两大常见失败模式
Remy 表示，在 Tailscale 负责 AI Gateway 项目期间，他与数百位正在探索如何提高 AI 部署 ROI 的客户进行了深入交流。在这些交流中，他观察到了企业在尝试控本增效时最容易踩入的两大失败模式（Failure Modes）：
第一种是**管理层/业务端的“一刀切供应商整合（Vendor Consolidation）”**。在季度末或半年末复盘时，业务高管们看着财务账单往往会陷入震惊：公司同时在向 Anthropic、OpenAI、Google Gemini 支付高额订阅费，同时内部还有人在用开源模型做实验，各类账单层出不穷。管理层的第一反应往往是：“这些工具看起来功能重叠，为什么不直接全盘整合到一家？”这种看似为了省钱的做法极其危险，它会把企业在未来一年内锁死在单一技术范式中。例如，如果某家公司在三个月前一拍脑袋决定“全面押注 Anthropic 和 Claude Code，砍掉其余所有供应商”，如今随着 OpenAI 发布新突破以及开源模型生态的爆发，这一决定瞬间就会陷入极其被动的境地。
第二种是**一线工程师（IC）端的“过早优化（Premature Optimization）”**。市面上有大量宣称能“通过魔法压缩节省 5% 上下文 Token”的开源项目，但这种优化往往得不偿失。首先，实际节省的成本微乎其微；其次，盲目的文本修剪会破坏服务商底层的 Prompt 缓存（Prompt Caching）机制——原本能命中低成本缓存的 Token 被打碎后，反而全变成了昂贵的未缓存输入；更致命的是，在本身就具备不确定性的大语言模型之上再叠一层非确定性的上下文过滤逻辑，会导致整个系统极不稳定。一旦模型底层升级，耗费数月构建的压缩逻辑就会瞬间作废。
---
### [07:12](https://www.youtube.com/watch?v=CXaFzIVqyes&t=432s) 迈向“ROI Maxing”：企业内部 AI 架构的四大核心组件
针对过去一年“Token Maxing”带来的种种乱象，Remy 预判未来 12 个月整个行业的主旋律将全面转向 **“ROI Maxing”（ROI 极限化）**——企业将不再盲目堆砌 Token，而是真正专注于如何从每一分 AI 基础设施投入中榨取出切实的业务价值。对于绝大多数并非为了自研基础模型、而是希望在组织内部落地 AI 赋能的企业而言，一套清晰解耦的 AI 架构包含以下四大核心组件：
1. **LLM 计算层（LLM / Compute Layer）**：决定组织选用哪些模型，以及内部员工或系统拥有调用哪些大模型算力的权限。
2. **数据连接器（Data Connectors）**：负责将企业上下文安全高效地喂给模型，涵盖 MCP 协议、业务 API、命令行 CLI 等一切数据流通管道。
3. **交互界面（Interface）**：必须将交互层与底层模型解耦。用户不应局限于直接访问外部网页（如 Claude.ai），企业内部正在兴起定制化的 Slack 机器人智能体、针对特定业务场景量身定制的内部 Chat 界面以及专业的本地编程终端。
4. **沙箱与执行环境（Sandbox & Execution Environment）**：这是当前演进最快、最具挑战性的新领域，专门用于承载 AI 智能体安全运行、执行命令与修改代码的受控隔离环境。
```mermaid
flowchart TD
accTitle: 企业内部 AI 架构四大核心支柱
subgraph EnterpriseAIStack["企业内部 AI 部署架构 (Internal AI Stack)"]
direction TB
subgraph Layer1["1. 交互界面 (Interface)"]
I1["定制化 Slack 智能体"]
I2["内部专用 Web 界面"]
I3["IDE / CLI 编程终端"]
end
subgraph Layer2["2. 沙箱与执行环境 (Sandbox & Environment)"]
S1["智能体隔离运行沙箱"]
S2["安全权限与运行时控制"]
end
subgraph Layer3["3. 数据连接器 (Data Connectors)"]
C1["MCP 协议管道"]
C2["内部业务 API"]
C3["CLI 与本地环境检索"]
end
subgraph Layer4["4. LLM 计算层 (LLM / Compute Layer)"]
L1["多模型路由 (Claude / GPT / Gemini)"]
L2["企业私有部署开源模型"]
end
Layer1 --> Layer2
Layer2 --> Layer3
Layer3 --> Layer4
end
```
### [09:01](https://www.youtube.com/watch?v=CXaFzIVqyes&t=541s) 降低选择的边际成本：通过 AI 网关实现堆栈解耦
在追求 AI 投资回报率（ROI）最大化的过程中，企业真正要做的是“在任何时刻都最大化选择的机会”。如果团队被深度锁定在某个端到端供应商技术栈中，一旦想尝试一款新模型或接入一个当前平台不支持的新数据源，就不得不全盘推翻重新评估。这种重构会让每一次细微调整的边际成本变得极其高昂，导致“在每一步看起来都不划算，算不过账来（the math doesn’t math）”。解决该困境的关键在于降低做决策的边际成本，而最佳落地手段就是引入 AI 网关（AI Gateway）来实现组件解耦。
这里所说的“AI 网关”并不仅限于市面上常见的单一领域方案，比如单纯的 LLM 网关或 MCP 网关等细分网关，而是一个能够控制、代理并全面观测组织内部所有 AI 部署流量的综合控制平面。在前置架构中部署此类网关后，企业能够获得细粒度的全景使用看板。管理员可以按人员、AI Agent、模型以及提供商等不同维度，清晰洞察具体的调用消耗、Token 使用量以及每百万 Token 的平均成本，从而在全局层面上自如调配资源。
- **选择的边际成本**：解耦底层模型与数据源，确保企业切换组件时无需重构整体架构。
- **全方位可视化**：集中监控人类员工与自主 Agent 的 Token 消耗，精确核算单位调用成本。
- **全能型定位**：打破单纯 LLM 或单一协议（如 MCP）代理的局限，纳管所有组织内部 AI 流量。
---
### [10:54](https://www.youtube.com/watch?v=CXaFzIVqyes&t=654s) 告别 API Key 分发：基于 Tailscale 与 TSNet 的身份原生连接
在传统的网关部署方案中，工程团队的通用做法通常是先将各大模型厂商的 API Key 配置在网关后端，接着再在网关上为组织内的每一位员工或每一个 Agent 批量创建并分发内部 API Key。这种做法在工程师群体中尚可通过既有的密钥管理系统勉强运转，但对于组织内的非技术人员（例如运营、市场、销售等）而言，分发和维护密匙极易演变成管理噩梦。Tailscale 打造的网关项目 Aperture 则开辟了一条完全不同的路径：直接摒弃 API Key 的分发流程，将网络连接本身的身份信息作为权限校验依据。
Aperture 底层深度整合了 Tailscale 的身份驱动型网状网络（identity-based mesh network）。Tailscale 能够将各类异构设备——无论员工的笔记本电脑、手机，使用星链（Starlink）网络身处大洋彼岸的船只，还是运行 AI Agent 的隔离沙箱——全部连接进单一的覆盖网络（overlay network）中。在这一架构下，Tailscale 区分了人类身份（Human Identity）与机器身份（Machine Identity），使得穿透网络的每一个请求都天然附带经过加密鉴权的来源身份。Aperture 内部利用开源的 Go 语言库 `tsnet` 直接读取该网络身份，无需发放任何 API Key，即可精准判断调用者是谁、是什么角色，并动态应用模型访问权限与用量配额。
```mermaid
flowchart TD
accTitle: 基于 Tailscale 身份的 AI 网关权限控制架构
accDescription: 展示不同实体通过自带网络身份连接 Aperture，进而统一访问受限模型与工具的解耦流程。
subgraph Clients["调用端（覆盖网络节点）"]
User["人类员工设备<br/>(Human Identity)"]
AgentNode["Agent 沙箱环境<br/>(Machine Identity)"]
end
subgraph NetworkControl["身份与代理控制平面"]
TSNet["TSNet 身份感知嵌入层<br/>(免 API Key 鉴权)"]
Aperture["Aperture (AI 网关)<br/>配额管理 / 访问控制"]
TSNet --> Aperture
end
subgraph Downstream["下游解耦资源"]
Models["LLM 集合<br/>(开源模型 / 前沿闭源模型)"]
DataSources["数据与工具<br/>(企业内部 API / MCP 工具)"]
end
User -- "原生网络请求" --> TSNet
AgentNode -- "原生网络请求" --> TSNet
Aperture --> Models
Aperture --> DataSources
```
- **免密鉴权机制**：不再层层派发内部 API 密钥，彻底解决跨部门分发密钥的操作摩擦。
- **原生双重身份体系**：清晰划分人类身份与机器身份，支持按需对二者施加不同的访问策略与配额限制。
- **嵌入式 TSNet 库**：服务程序可在代码中直接利用 `tsnet` 解析网格网络上下文，将网络连通性与权限管控无缝捏合。
---
### [13:00](https://www.youtube.com/watch?v=CXaFzIVqyes&t=780s) 统一四层架构：模型、数据层（MCP）、界面与沙箱环境
在梳理内部 AI 体系时，整个基础设施通常由四个核心组件构成：LLM 模型、数据连接器、前端交互界面以及底层运行沙箱。借助统一的 AI 网关，这四层均可实现标准解耦。首先在模型层，管理员将所有厂商的原始密钥收敛在网关单一入口，并编写简明易懂的访问控制策略——例如为特定常规业务部门分配低成本的开源模型，为需要尖端推理能力的攻坚团队分配前沿（Frontier）闭源模型，员工与业务端只需面向同一个统一下游端点发起调用。
```mermaid
flowchart LR
accTitle: AI 架构四层解耦模型
accDescription: 展示从模型、数据连接器、交互界面到沙箱环境的四层解耦机制。
L1["模型层 (LLM)"] --- L2["数据层 (MCP)"]
L2 --- L3["界面层 (Chat UI)"]
L3 --- L4["沙箱层 (Sandbox)"]
subgraph L1Decouple["模型解耦"]
L1 --> L1D["统一端点<br/>按身份动态路由开闭源模型"]
end
subgraph L2Decouple["数据解耦"]
L2 --> L2D["网关单点认证<br/>跨外部工具复用凭证"]
end
subgraph L3Decouple["界面解耦"]
L3 --> L3D["自研/定制 UI<br/>底层切换模型无需重新培训"]
end
subgraph L4Decouple["执行解耦"]
L4 --> L4D["适配多沙箱运行时<br/>屏蔽冷启动与供应商差异"]
end
```
在数据与工具层（特别是 Model Context Protocol, MCP 协议领域），传统模式下每当推荐员工尝试新工具时，员工都必须在新系统里把工具 A、B、C、D、E 全部重新登录认证一遍，这种极高摩擦力会抑制工具的普及。而在 AI 网关架构下，终端用户只需在网关内部完成一次认证，网关即可沿用模型层同一套权限规则分发工具访问权，形成“单端点统管模型、单端点统管数据”的高效范式。
针对交互界面与执行沙箱，解耦的价值同样立竿见影：
- **定制化独立界面**：主流大模型厂商希望“掌控整个软件栈以扩展利润空间（own more of the stack and expand your margin）”，但企业可以基于网关的统一接口定制专属聊天前端（如客服团队专用 UI）。当底层模型需要从 Claude 切换到其他服务商时，无需让全员推倒重来去适应全新界面。
- **敏捷沙箱适配**：当前 AI 沙箱领域的发展速度甚至超越了 LLM 本身，执行速度与冷启动时间在各大供应商之间按月轮替。通过网络连接层与控制层的统一收敛，企业无论底层选用 Vercel Sandbox 还是其他自建容器环境，都能让 AI Agent 安全受控地回连至网关，无惧外部技术格局的高频迭代。
### [17:46](https://www.youtube.com/watch?v=CXaFzIVqyes&t=1066s) 最大化 ROI 与保留选择权：构建灵活无锁定的 AI 架构
演讲在最后着重强调，实现 AI 投资回报率最大化（ROI maximizing）的关键在于“最大化选择权（maximizing choice）”，从而有效避免技术与供应商锁定（lock-in）。企业需要在早期架构设计时就为长期成功做好铺垫，通过引入 AI 网关（AI Gateway）以及基于身份的安全连接架构，建立起坚实的基础设施底座。
AI 的落地与迭代是一个渐进式的过程。当新的技术选择和业务决策逐步到来时，这种架构能让团队从容做出调整，而不会每次面临变更时都陷入“这笔账在经济或架构上根本算不过来”的窘境。Tailscale 的目标正是化繁为简，让企业在迈向 AI 生产落地的每一步中，都能极其轻松地做出正确决策。在演讲尾声，Remy Guercio 感谢了现场观众，并热情邀请大家在会后前往 Tailscale 展台展开进一步的交流与探讨。
- **防止供应商锁定**：通过在架构初期引入 AI 网关与灵活的连接层，确保底层模型与服务可随时平滑切换。
- **降低决策阻力**：消除基础设施重构带来的隐性成本，让后续的每一次架构迭代都经济可行。
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) Token Maxing（Token 极限化/算力拉满）……代表了整个行业都在探索如何将 AI 和 Token 的能力压榨到极致：只要把所有能拿到的东西统统扔给大模型，究竟能做成什么？ — Remy Guercio
> [00:04](https://www.youtube.com/watch?v=CXaFzIVqyes&t=4s) 开发者只需向 AI 下达一个任务，嘱咐一句“请千万别犯错”，就能直接起身离开工位，稍后回来查看完整成果。 — Remy Guercio
> [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) 现有的许多 UI 交互工具以及 MCP 的原始设计，在默认机制上就在变相鼓励浪费 Token——系统不断诱导用户“尽管往里面塞数据，反正我们会做上下文压缩”。 — Remy Guercio
> [02:45](https://www.youtube.com/watch?v=CXaFzIVqyes&t=165s) 企业一旦采用某种方案，往往就会被锁死在“单一模型 + 单一服务商 + 单一前端界面”的死胡同里，丧失了灵活切换与混合编排的能力。 — Remy Guercio
> [04:19](https://www.youtube.com/watch?v=CXaFzIVqyes&t=259s) 这些工具看起来功能重叠，为什么不直接全盘整合到一家？ — Remy Guercio
> [04:19](https://www.youtube.com/watch?v=CXaFzIVqyes&t=259s) 在本身就具备不确定性的大语言模型之上再叠一层非确定性的上下文过滤逻辑，会导致整个系统极不稳定。一旦模型底层升级，耗费数月构建的压缩逻辑就会瞬间作废。 — Remy Guercio
> [07:12](https://www.youtube.com/watch?v=CXaFzIVqyes&t=432s) 未来 12 个月整个行业的主旋律将全面转向“ROI Maxing”（ROI 极限化）——企业将不再盲目堆砌 Token，而是真正专注于如何从每一分 AI 基础设施投入中榨取出切实的业务价值。 — Remy Guercio
> [09:01](https://www.youtube.com/watch?v=CXaFzIVqyes&t=541s) 企业真正要做的是“在任何时刻都最大化选择的机会”。 — Remy Guercio
> [09:01](https://www.youtube.com/watch?v=CXaFzIVqyes&t=541s) 这种重构会让每一次细微调整的边际成本变得极其高昂，导致“在每一步看起来都不划算，算不过账来（the math doesn’t math）”。 — Remy Guercio
> [10:54](https://www.youtube.com/watch?v=CXaFzIVqyes&t=654s) 直接摒弃 API Key 的分发流程，将网络连接本身的身份信息作为权限校验依据。 — Remy Guercio
> [13:00](https://www.youtube.com/watch?v=CXaFzIVqyes&t=780s) 主流大模型厂商希望“掌控整个软件栈以扩展利润空间（own more of the stack and expand your margin）”。 — Remy Guercio
> [17:46](https://www.youtube.com/watch?v=CXaFzIVqyes&t=1066s) 实现 AI 投资回报率最大化（ROI maximizing）的关键在于“最大化选择权（maximizing choice）”，从而有效避免技术与供应商锁定（lock-in）。 — Remy Guercio
## Mentioned
Remy Guercio, Tailscale, AI Gateway, Model Context Protocol (MCP), Anthropic, Claude Code, Claude.ai, OpenAI, Codex, OpenCode, Pi, Google Gemini, Aperture, tsnet, Starlink, Vercel Sandbox, Slack
## Video description
Remy Guercio - Strategic Projects, Tailscale
What if the biggest barrier to successful AI adoption isn’t your model but the infrastructure around it?
Most companies are not trying to train their own models. They are trying to integrate AI into real products, workflows, and internal systems. The real challenge appears after the prototype works and teams try to safely connect AI to production data, internal APIs, and the services that power their applications.
Suddenly what looked like a fast path to value turns into months of networking changes, security reviews, and fragile infrastructure. This talk explores the hidden infrastructure tax that slows AI adoption through exposed endpoints, complex connectivity between services, and overprivileged systems.
I will show how identity based connectivity simplifies AI architecture, keeps services private, and enforces granular access across people, applications, and AI agents.
The result is faster time to production, stronger governance over AI enabled systems, and the ability to safely connect AI into existing products without exposing critical infrastructure. If your organization is trying to turn AI adoption into real business value, this session shows why solving connectivity is one of the fastest ways to move forward.
[Source](https://www.youtube.com/watch?v=CXaFzIVqyes)
Source quotes
[0:04] Remy Guercio: Token Maxing（Token 极限化/算力拉满）……代表了整个行业都在探索如何将 AI 和 Token 的能力压榨到极致：只要把所有能拿到的东西统统扔给大模型，究竟能做成什么？
[0:04] Remy Guercio: 开发者只需向 AI 下达一个任务，嘱咐一句“请千万别犯错”，就能直接起身离开工位，稍后回来查看完整成果。
[2:45] Remy Guercio: 现有的许多 UI 交互工具以及 MCP 的原始设计，在默认机制上就在变相鼓励浪费 Token——系统不断诱导用户“尽管往里面塞数据，反正我们会做上下文压缩”。
[2:45] Remy Guercio: 企业一旦采用某种方案，往往就会被锁死在“单一模型 + 单一服务商 + 单一前端界面”的死胡同里，丧失了灵活切换与混合编排的能力。
[4:19] Remy Guercio: 这些工具看起来功能重叠，为什么不直接全盘整合到一家？
[4:19] Remy Guercio: 在本身就具备不确定性的大语言模型之上再叠一层非确定性的上下文过滤逻辑，会导致整个系统极不稳定。一旦模型底层升级，耗费数月构建的压缩逻辑就会瞬间作废。
[7:12] Remy Guercio: 未来 12 个月整个行业的主旋律将全面转向“ROI Maxing”（ROI 极限化）——企业将不再盲目堆砌 Token，而是真正专注于如何从每一分 AI 基础设施投入中榨取出切实的业务价值。
[9:01] Remy Guercio: 企业真正要做的是“在任何时刻都最大化选择的机会”。
[9:01] Remy Guercio: 这种重构会让每一次细微调整的边际成本变得极其高昂，导致“在每一步看起来都不划算，算不过账来（the math doesn’t math）”。
[10:54] Remy Guercio: 直接摒弃 API Key 的分发流程，将网络连接本身的身份信息作为权限校验依据。
[13:00] Remy Guercio: 主流大模型厂商希望“掌控整个软件栈以扩展利润空间（own more of the stack and expand your margin）”。
[17:46] Remy Guercio: 实现 AI 投资回报率最大化（ROI maximizing）的关键在于“最大化选择权（maximizing choice）”，从而有效避免技术与供应商锁定（lock-in）。
Source quotes
[0:04] Remy Guercio: The AI landscape over the past 12 to 18 months has been defined by an aggressive push to push model capabilities to their absolute limits—a trend frequently referred to as 'token maxing.'
[2:45] Remy Guercio: When teams adopt these integrated silos, they forfeit the flexibility to swap components as the model landscape evolves.
[4:05] Remy Guercio: The business-level failure mode occurs when directors or managers review quarterly invoices and discover redundant, expensive subscriptions across OpenAI, Anthropic, Google Gemini, and various self-hosted open-weight models.
[7:07] Remy Guercio: The industry is entering a transitional phase from 'token maxing' to 'ROI maxing,' shifting focus from raw capability consumption to maximizing tangible business return on AI deployments.
[7:07] Remy Guercio: Achieving ROI maxing requires organizations to minimize the marginal switching cost of changing any part of their AI architecture at any moment.
[9:44] Remy Guercio: Tailscale addresses this credential bottleneck in its AI gateway, Aperture, by anchoring access directly to network identity rather than static tokens
[14:48] Remy Guercio: You get access to these tools or you get access to these endpoints
[15:17] Remy Guercio: If a team builds their daily routines around a provider interface like Claude, switching to a more cost-effective or capable alternative later requires retraining the entire company on an unfamiliar interface.
[16:39] Remy Guercio: ROI maxing is maximizing choice, right, to prevent lock-in.
[16:39] Remy Guercio: When infrastructure is architected around an identity-first gateway from the outset, companies can navigate the rapid twists of the AI ecosystem incrementally, adopting the best models and runtimes available without facing prohibitive switching costs.
Original transcript
[0:04] Hi everyone. Thanks for coming. Uh yeah, my
name is Remi. I work at Tailscale in strategic
[0:09] projects, specifically on our AI gateway and
other AI and AI enabled and AI projects inside
[0:15] of Tailscale. So, um yeah, today I do want to talk
about how connectivity and identity unlock real
[0:21] AI ROI inside of your organization and
how they can help do that. I know ROI
[0:25] is a very complicated topic. So, um before
I want to talk about ROI and driving ROI,
[0:31] I want to take a look back at the last 12 months
or so. So, uh I think you can if I don't know,
[0:37] I'm kind of curious as to how many people know
this term, token maxing, have heard this term.
[0:42] Yeah. Yeah, yeah. So, that's basically using
using tokens kind of to their fullest extent,
[0:46] using AI to its fullest extent. Uh it's
typically seen as kind of a pejorative term,
[0:50] but I'm I'm not really using it that way
here. I'm using it more in the sense of
[0:55] uh the last 12 months have been all about
and 12 to 18 months have been all about
[1:00] basically what does it mean to like really, really
use AI? If you just throw everything at it, like
[1:05] what can you do with all the latest advancements?
So, that means million token context windows,
[1:10] right? These, you know, about a, you know, year,
year and a half ago, all of these models suddenly
[1:14] got, you know, really, really large context
windows where they can suddenly reason and
[1:18] look at all kinds of things, uh you know, just an
incredible amount of data. Um the next thing was,
[1:24] you know, MCP, right? You know, everybody's kind
of familiar with MCP now, but it's not very old.
[1:29] Uh and it kind of went from nothing, nobody'd
ever heard of it, to everywhere, pretty much
[1:33] feeling like overnight. And in reality, you can
think of that as, you know, we had the million
[1:37] token context windows, they can kind of look at
all this stuff, and then everything else is like,
[1:41] how much stuff can we actually stuff into the
context window? So, hey, let's go get data from
[1:46] all of our different sources, everywhere that you
have it. Um and then the same thing is, you know,
[1:50] coding tools, they actually got really great
at finding a bunch of context via the CLI. So,
[1:54] uh you you we had MCP for, you know, all
sorts of regular corporate data, your email,
[1:59] and other things. We had coding tools show up with
the ability to just kind of find files and look at
[2:03] files and pick parts of files from all over your
computer, uh and put everything together. And so,
[2:07] when we put that all together, uh this is
I mean, this has been the big story, right,
[2:12] of the last 12 months is agentic coding went from
kind of like a we went from sort of the like oh,
[2:18] uh I'm it's a better search for like a problem
that I have, or, you know, I'm going to be using
[2:22] it like VS Code, and it's going to do awesome
auto complete, or maybe it can do a little
[2:26] extra than that, you know, maybe make a file, or
whatever part of a file to oh, now I could just,
[2:31] you know, ask it to do a thing. Please don't make
any mistakes, and kind of walk away and come back,
[2:35] uh or just keep asking it to do things, and have
it do all sorts of things. So, um that's been the
[2:40] benefit, right? So, token maxing is basically made
something that was previously impossible possible.
[2:45] Um but, it obviously has some problems,
and I think this is what you're
[2:49] you know, probably feeling if you're in an
organization like this, you're probably feeling,
[2:52] uh is token maxing is obviously very expensive.
Uh these these models get really expensive. They
[2:58] get even more expensive when your context
window gets huge. Uh so, it's, you know,
[3:03] it's just it's not not a cheap endeavor.
Um and also, the sort of, you know, mode,
[3:08] and kind of like the way MCP was originally
built, and kind of all of these UI tools,
[3:12] it sort of incentivized wasting tokens by
default. So, it's just incentivizing people
[3:16] to kind of like, hey, keep throwing stuff at it.
Keep putting it in. Keep doing it. Like, oh, we'll
[3:19] compact the window. We'll do all of this stuff.
Just keep throwing stuff at it. Uh and so, you
[3:23] kind of end up in the situation where it's like,
great, it did the thing, but it did it, you know,
[3:28] at what cost effectively. Um and then the last
thing is this is, you know, this hasn't been
[3:32] sort of an even distribution, right? Like the as
we've seen with Claude Code, and then Codex, and
[3:37] all of the open tools, if you've heard of the kind
of open coding tools, like open code and pie, and
[3:41] things like that, they've all um it's it's not
been an even thing. So, we've ended up with these
[3:46] basically these vertically integrated tool chains,
especially with like Claude Code and Codex,
[3:51] uh where um you know, you're kind of stuck
with a single model to a single provider to
[3:56] a single interface. All of this kind of
just a stack that you're locked into. Um
[4:01] And so, you know, that that's kind of the problems
that we've had, but how do we address them, right?
[4:05] So, how do we you know, it's cool, this thing that
used to be impossible now works in many cases. Uh
[4:13] Not so great that it's extremely expensive. Uh you
know, and so how do we do this? So, first is kind
[4:19] of how not to address the problem. So, I mentioned
I work on our AI gateway. And as part of that,
[4:24] uh I've talked to like hundreds of, you know,
people as we've kind of been uh you know,
[4:29] you know, talking about the AI gateway with
folks about kind of like what they're doing,
[4:32] like what are they thinking about in
terms of like improving the ROI of their
[4:36] uh of of their AI deployments. And uh I see
kind of two failure modes. There's kind of the
[4:41] uh sort of manager and sort of director level
failure mode uh or sort of like business side
[4:46] failure mode, and then there's sort of the like
IC failure mode. On the business side of things,
[4:50] uh typically this shows up as a you've
received a bill or you've kind of like
[4:54] we're the end of the quarter or you
know, it's kind of the end of a half,
[4:57] uh and you suddenly see the fact that, you know,
you have an Anthropic subscription and a you know,
[5:02] an OpenAI subscription and a Gemini subscription
and, you know, somebody's doing some things with
[5:06] open models off over here and you know, we have
bill after bill after bill after bill and they're
[5:10] all huge. Uh and so, the question becomes is like,
well, can you know, I hear all of these things
[5:16] that kind of do the same thing, you know, there's
a lot of overlap. Uh can't we just consolidate?
[5:21] Uh I hear that over and over and over again. Uh
it is not a great, you know, it's a great way to
[5:24] save a little bit of money to lock yourself into
a particular paradigm for the next year. And as
[5:30] we've seen, if you had maybe done this 3 months
ago and you were like, "Hey, I'm going to go all
[5:33] in on Anthropic and Claude code. We're going
to cut out everything else for now. We're just
[5:37] going to really get visibility on, you know, what
we're doing here with, you know, Anthropic." Uh
[5:42] that maybe doesn't look like the best
decision now. Uh so, you you suddenly,
[5:45] you know, OpenAI is on top of the world. And then
after that, it's all the open models and now on
[5:49] top of the world and you kind of ended up locking
yourself into a single single contract. So,
[5:53] that's the first failure mode. The second failure
mode is sort of the kind of IC failure mode. And
[5:58] what that turns out to be is typically
a bit of uh premature optimization. So,
[6:05] you know, if you're kind of uh looking for
ways to save tokens and all this sort of stuff,
[6:09] there's a plethora of projects out there that
are all like, "Hey, you know, we know how to save
[6:14] 5% of your context window, we can do, you know,
like some fancy magic and like or even some basic
[6:20] magic and just uh you know, save you tokens."
Um the problem is there is A, the savings,
[6:26] the real savings are usually kind of kind of
small. Um there's always some trade-off. Sometimes
[6:31] it's hidden in the sense that it's like uh it's
just sort of like, "Oh, now we've uh you basically
[6:37] are not getting cached tokens, we're just getting
uh expensive tokens now. So, it's like, yes, we've
[6:41] saved tokens, but now they're all expensive."
Or you end up in the situation you where you
[6:45] basically put it like a non-deterministic system
on top of a non-deterministic system and so uh
[6:50] people are like, "Well, it kind of worked for me."
And then it doesn't work and then maybe it saved
[6:54] a little money and I don't know whether or not
it saved any money. Uh and it's like, "Okay, to
[6:58] maybe save 5% we've kind of done all of this work
and put out all of these things and then a new
[7:03] model comes out and it's all kind of wasted anyway
cuz you got to figure it out all over again. So,
[7:07] those are the kind of two failure modes um that
we see. And that's because, you know, people are
[7:12] I think grasping for what I would say the next
12 months is going to be and I just, you know,
[7:17] if you have an opportunity to try and coin a
term, I'm just going to use it over and over
[7:20] again. I think we're going to go from token maxing
to ROI maxing, right? People are actually going to
[7:24] be trying to figure out uh how, you know, how do
I get my money's worth out of these deployments?
[7:29] Uh and I like this sort of moniker. So, yeah,
we'll say next 12 months ROI maxing. Um and
[7:35] to really understand ROI maxing, we have
to first kind of dive into what the kind of
[7:41] what I would say the like the key core
components of uh internal AI deployment. So,
[7:44] like for your your organization, not necessarily
if you're building like a you know, public-facing
[7:48] agent or things like that or you're an AI company,
but if you're just trying to leverage AI and these
[7:53] are the four components. So, the first one is
just obviously is the LLM, right? So, it's which
[7:57] LLM that you choose, it's which LLMs that you have
access to, that your employees have access to, uh
[8:02] you know, that is the kind of compute layer of the
kind of AI stack and uh that's at the LLM side of
[8:07] things. Then there's the data connectors, right?
So, this is bringing in content via MCP, via APIs,
[8:13] CLI, pretty much anything that you can think of,
right? It's all of the data. How do we you know,
[8:16] how do we you know, we've decided on our LLMs,
how do we get our data in? Um the next is the
[8:21] interface and I mean, I think a lot of people
don't necessarily separate this from the AI
[8:25] itself, right? If you go to you know, Claude.ai,
right? You're going to get a Claude model, but
[8:30] that's not a thing that has to be together.
You can have a separate user interface,
[8:34] right? From the actual model itself. We see that
with like the rise of sort of Slack bot agents
[8:39] and you know, people are starting to build their
own chat interfaces that are specifically designed
[8:44] around their use cases and inside their org.
Um and a lot of things along those lines. So,
[8:48] and then obviously in the coding world, there's
there's plenty of these. Um so, there's that
[8:52] and then the last one and this is kind of the the
newest and still very fast-moving side of things,
[8:56] which is sort of the sandbox and the environment
that the agents are actually running in. Um so,
[9:01] you know, these are the four things that you
kind of have to think about and when it comes
[9:05] to ROI maxing, in reality, what you're trying to
do is you're trying to maximize the opportunity
[9:09] for choice at any moment. So, we want to
reduce the marginal cost of making a choice
[9:14] to say I want to go outside of you know, this
sort of stack. I want to choose something
[9:19] slightly different. We want to make that really,
really easy to do uh to actually improve the
[9:24] ROI cuz in reality, when you get locked into
the whole stack, as soon as you're like, oh,
[9:27] maybe I want to try a different model. Maybe I
want to try a different like I want to connect
[9:30] to some other data source that doesn't exist.
Now, you're rethinking the whole thing and so,
[9:34] you can't make those like marginal marginal
improvements uh on ROI without kind of
[9:39] at every step it always doesn't look right, right?
The math doesn't math and so you want to actually
[9:44] maximize the choice for opportunity. And the way
to do that, right? So I work on an AI gateway. Not
[9:49] saying it's necessary to use our AI gateway, but
if you want to using an AI gateway is a fantastic
[9:54] way to do this because what you get to do is you
get to decouple all of that stuff by using an AI
[9:58] gateway. And I'm specifically using the term
AI gateway here, so I'm not saying LLM gateway
[10:03] probably heard or MCP gateway or you know, we
got kind of the the niche gateway, niche gateway,
[10:08] niche gateway. Um what I mean is an gateway that
basically helps you sort of control and proxy and
[10:13] see all of your traffic that has to do with
an AI deployment inside of your organization.
[10:17] So it's very you know, that's a this is a very
important step here. Again, this is how you you
[10:22] make this decision up front and it lets you make
these sort of marginal cost decisions later on.
[10:27] Um in the case of our gateway, right? So it looks
like this, right? So you get to see things like
[10:33] and this is a great thing about an AI gateway. You
get to see things like a usage overview in terms
[10:36] of both people and agents and how much they spent
and what tokens they spent and what models they
[10:41] spent tokens on and like what was their average
cost per million tokens and everything you
[10:45] you know, to your heart's desire. You as an
admin can see. You can see it on an agent basis,
[10:49] model basis, provider basis. It really you know,
anything that you kind of kind of or you know,
[10:54] would or would want here. Um now typically with
a gateway deployment, so you know, we talked to
[11:02] a lot of folks that are typically trying to
do this on the engineering side of things.
[11:06] And what that typically involves is you hey I
deploy a gateway and then you put all your API
[11:11] keys for you know, your various different model
providers and things in that gateway and then you
[11:14] take that and then you say now here I'm going to
create an API key for everybody in my organization
[11:19] or every agent in my organization kind of over
and over and over again. And so you kind of taken
[11:22] a few API keys and then you've given everybody
a like you've kind of just you know, we've gone
[11:27] from just a few and that you you know, might use
over and over or like you would be giving like
[11:31] three to everybody in your org to you're still
giving a bunch to everybody in your org. Um that
[11:36] works for engineers. You probably already have
like a, you know, their systems set up in place
[11:41] for distributing those. Doesn't really work for
people in other parts of the org as well, right?
[11:45] It's not not something that's easy. And that's
where we try to be a little different here. So,
[11:49] um you can actually do this in aperture without
uh distributing API keys to your organization.
[11:54] You can just do it based on identity that it comes
from a network connection. Um and that is because
[11:59] so, aperture itself is built on tailscale. And
if you're not familiar with tailscale, tailscale
[12:04] is an identity-based mesh network that connects
devices into a like a single overlay network. So,
[12:09] you install tailscale on all of your different,
you know, this could be phones or laptops. It
[12:14] could be a literal boat in the middle of the
ocean using Starlink or something like that.
[12:18] It can be installed anywhere. It can be installed
in your agent sandbox. Like truly, truly anywhere.
[12:23] Once you've installed it all over the place, uh
we basically have two forms of identity. There's
[12:27] a human identity and a machine identity
that kind of uh comes along with this.
[12:31] And every network request that's made across
the network comes with that identity built in.
[12:36] So, aperture itself actually uses uh a
open-source Go library that we have called TSNet,
[12:42] which lets it read that identity information.
And it then knows who you are, what you are,
[12:47] and then it can decide basically what permissions
you have, what models you can access, what quotas
[12:51] apply to you, and everything along those lines
without having to distribute API keys at all. Um
[12:56] again, we're trying to make this easy, right? To
make this sort of like this uh deployment easy
[13:00] so you can make all these choices. And again, uh
when we think about the components of an internal
[13:04] AI deployment, right? So, how does that gateway
How does this apply to the gateway? So, we have
[13:08] this gateway, it knows your identity, it can kind
of do everything that you expect. Um you know,
[13:12] we have the LLMs, we have the data connectors,
the interface, and the sandboxes, and the kind
[13:16] of environment that things run in. When it comes
to the LLM side of things, uh again, you just take
[13:21] all those keys, single keys, you know, everything
you have from all your different providers, you
[13:25] put it into one spot. You write basically simple
access control rules. You can say, "Hey, here
[13:30] you know, you get access to these models, you
get access to these models, these open models,
[13:34] these closed models." It doesn't matter, right?
Like maybe if you're in one part of the org,
[13:37] you get access to cheap models or kind of like
the open source side of things. If you're a part
[13:41] of a org if you're in a part of the org that needs
sort of very frontier AI, you get access to that.
[13:46] But you basically get you get the ability to kind
of pick and choose with only one endpoint for
[13:51] folks to hit. So it's not like you need to sign
up for this service or service or that service or
[13:55] whatever. It's just a single endpoint. So that's
the single like that's basically on the LLM side
[14:01] of things. So again, AI gateways do this. This is
not necessarily unique to Tailscale, but like that
[14:05] is the you know, that is the core of core of what
you do there. The next side of things is the data
[14:10] layer. So we talked about the LLMs. That's great,
you know, you can choose whatever providers.
[14:14] People do that and then all of a sudden it's like,
"Well, we have all these providers. They can go
[14:18] back and forth between whatever they want."
However, in that tool, I've authenticated to
[14:22] tools A, B, C, D, and E. And so when you're again,
you're trying to get somebody in the organization
[14:26] to be like, "You should try this other tool or
you should try this or you should use that."
[14:32] In their head again, we're thinking about reducing
that marginal cost at any given point in time.
[14:36] They're like, "Well, now I need to log in
to literally everything that I have again
[14:40] in that other tool." When you get to again, when
you get to decouple things with the AI gateway,
[14:44] again, this is on the MCP side of things. What
it looks like is this. You actually as the
[14:48] end user go into the gateway, authenticate to all
your various tools inside of the gateway, and then
[14:55] we get to use those same access control rules that
we're using for the LLMs and the models to say,
[14:59] "You get access to these tools or you get access
to these endpoints. You don't you you now have one
[15:04] endpoint that controls all your data access and
one endpoint that controls all your LLM access
[15:08] where you're controlling everything and seeing
everything and then being able to distribute
[15:11] it." So it's that easy. So again, you know, we've
talked about the LLM, the data side of things.
[15:17] Then we have the interface. So again, it's
typically you know, people think of the interface
[15:22] is, you know, very much coupled obviously to
the model. It's it's kind of what the labs want,
[15:27] right? They This is how you get a higher margin
if, you know, inference costs if you keep getting
[15:31] beaten, you know, with open models on inference
costs and things like that, you obviously want to
[15:36] you know, you obviously want to kind of own
more of the stack and expand your margin.
[15:40] Um we have actually basically uh built our own
chat UI that is actually attached to aperture.
[15:46] Um not necessarily as a thing that I'm saying
you have to use, but more as a demonstration of
[15:51] a thing that you can do on top of a gateway. So,
again, you get to leverage all of this identity
[15:55] information. Everything we've done here, you can
you can do yourself. So, if you want to take this
[16:00] and kind of run with it and, you know, we'll talk
about that, or uh you just want to build using the
[16:04] same endpoints uh that we have and basically have
all that same control, but have your own custom UI
[16:10] for your support team, right? So, own custom chat
UI for, you know, support or customer success, or,
[16:15] you know, anybody else. You can you can do
that with something like uh an AI gateway. So,
[16:20] it's not everybody using, you know, Claude.
And then the moment you're like, "Oh, we need
[16:24] to switch to something else." You have to retrain
the entire company on like a different interface.
[16:28] You can say, "Hey, we want to train companies
on our own interface." Or a specific or this
[16:32] interface that we can then take and swap the
models and swap the data underneath without
[16:37] people having to relearn everything. And then the
last thing, and this is where it's kind of fun and
[16:42] uh I guess you could say open to interpretation.
Now, this is a very fast-moving side of things,
[16:46] but, you know, sandbox situation is very, very uh
you know, is basically uh it's a very fast one.
[16:52] If LLMs are a very fast-moving space, the
sandbox space is even faster than that
[16:57] uh with all sorts of new developments and things
like that. But, what we think is most important
[17:00] again is being able to connect everything such
that it doesn't matter who's the winner right now,
[17:06] cuz it literally changes every single month
as to who's the most popular, you know,
[17:11] who's got the best, you know, who's got the best
model for this, who's got the best model for that,
[17:14] who's fastest on their sandboxes, who's got the
lowest cold start times. It's it's, you know,
[17:19] back and forth and back and forth. So, again,
we want to take that same principle and you can
[17:23] attach, in this case, we're actually
using a sandbox under the hood,
[17:26] um and we're using a Vercel sandbox here, but it's
not that you have to use a Vercel sandbox. You can
[17:32] actually put these agents in any sort of sandbox
system that you want and then connect them again
[17:36] uh back to aperture or, you know, or any other
gateway that you have. Uh it's just happens
[17:40] to be very convenient when the connectivity and
the sort of control are all together in one. So,
[17:46] just to leave you with here, you know, remembering
RLI maxing is maximizing choice, right, to prevent
[17:50] lock-in. And again, it's setting yourself up
for success up front by choosing something like
[17:55] an AI gateway, by starting with an architecture
like this. So, when it comes time to make those
[18:00] decisions because they come incrementally, you
can make them uh and, you know, you don't have
[18:04] to it's not every time you do that it's not like,
"Oh, I'm going to, you know, I have to do this uh
[18:09] you know, the math that doesn't work out,
right?" You want we want to make it easy
[18:12] for you to basically make the right decision at
each step of the way uh to do that. So, that's it.
[18:17] Thank you very much. Happy to chat afterwards.
Happy if you find me at the Tailscale booth.
