# An AI Future Without the Lock-In

Remy Guercio, Tailscale | AI Engineer World's Fair 2026 | 19:38

Source: https://www.youtube.com/watch?v=s-glGHAa1a4
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/an-ai-future-without-the-lock-in
Published: 2026-10-11
Tags: cost, enterprise, observability, security

## TL;DR
- AI teams are moving from maximizing token use to proving return on investment and controlling waste.
- An internal AI deployment has four separable layers: models, data connectors, interfaces, and sandboxes.
- An AI gateway can centralize identity, budgets, authentication, and logs while keeping those layers replaceable.

## Summary
Remy Guercio argues that the past year of AI adoption pushed teams toward expensive, vertically integrated tool chains. Long sessions can consume millions of tokens, while tools such as Claude Code and Codex combine models, agents, interfaces, and connectors in ways that make switching difficult. He calls the next phase "ROI maxing", which includes proving value and making cheaper models and new workflows usable across an organization. He breaks an internal AI deployment into four layers: LLMs, data connectors, interfaces, and sandboxes. An AI gateway can sit between those layers and provide a common place for model access, MCP servers, authentication, budgets, and usage logs. Using Aperture as the example, he explains how Tailscale identity removes the need for shared or synthetic API keys, how budgets can differ by model, and how logs help diagnose agent behavior. The argument applies even to individual users who want to understand what an agent did.

## Key ideas
### Token-heavy AI use has become expensive and wasteful
[00:36](https://www.youtube.com/watch?v=s-glGHAa1a4&t=36s)
Guercio describes the last year as a period of "token maxing", enabled by million-token context windows, MCP, coding tools, and CLIs that bring context into models. This made agentic coding possible, but it also created high costs. He sees sessions that run for hundreds or thousands of messages without clearing context. Some accumulate tens of millions of tokens while the cache remains full. Long sessions can be useful, but the default behavior often spends tokens without a clear reason. Guercio also points to vertically integrated tools such as Claude Code and Codex, which build from the model up through the agent and tool chain.

### Consolidating on one AI vendor does not solve lock-in
[03:20](https://www.youtube.com/watch?v=s-glGHAa1a4&t=200s)
After speaking with hundreds of people about AI spending, Guercio says the common response to an unexpected bill is to standardize on the tool everyone is using, perhaps with a second vendor. Finance asks why the company is spending so much, and the team tries to regain control by choosing one product. Guercio says this is understandable in a panic, but it creates another dependency. A company can reduce the number of vendors while making it harder to test cheaper models, different agents, or new workflows. The immediate feeling of control can therefore limit future choices.

### ROI maxing means proving value while expanding choice
[05:14](https://www.youtube.com/watch?v=s-glGHAa1a4&t=314s)
Guercio proposes "ROI maxing" for the next phase of internal AI use. He does not mean only cutting costs. Teams also need to show that a use case creates value and make AI affordable enough to expand beyond a small set of frontier-model users. If the organization can use only two expensive models and their surrounding ecosystems, many possible applications remain impractical. ROI depends on being able to choose the right model and workflow for each situation. Different teams may need different interfaces and tools, so a single company-wide setup is unlikely to fit everyone.

### An internal AI deployment has four layers
[06:09](https://www.youtube.com/watch?v=s-glGHAa1a4&t=369s)
Guercio divides an internal AI deployment into four parts. The first is the LLM layer. The second is the data connector layer, which can include MCP, CLIs, APIs, or simply reading files into an agent system. The third is the interface, ranging from chat and IDEs to phones and Slack. The fourth is the sandbox, meaning the environment where the agent runs. ROI depends on retaining the ability to choose at each layer. A marketing team might ask data questions in Slack, while an engineering team uses a different interface. The layers should not be forced into one tightly coupled product.

### Aperture puts model and data endpoints behind one gateway
[08:09](https://www.youtube.com/watch?v=s-glGHAa1a4&t=489s)
Aperture sits between agents and their interfaces on one side, and LLM, MCP, and API endpoints on the other. Guercio presents it as a place to control and monitor security, cost, and agent activity. Logs let a team inspect a session that failed to reach an answer, spiraled out of control, or behaved differently than expected. The agent can also analyze its own earlier activity to help explain the failure. Aperture handles both LLM access and data access, which is why Guercio uses the broader term "AI gateway" rather than only "LLM gateway".

### Tailscale identity removes the need for shared gateway keys
[10:09](https://www.youtube.com/watch?v=s-glGHAa1a4&t=609s)
Aperture is built on Tailscale, an identity-based mesh network built on WireGuard. Devices, containers, laptops, and GPU servers on the tailnet carry the identity of the user or machine making a connection. That identity can be a user, a machine tag, or an agent such as a pull request review bot. Tailscale can also sync groups from systems such as Entra or Okta. Aperture uses the open-source TSNet library to build this connection. This lets the gateway recognize who or what is connecting without replacing provider keys with a new collection of synthetic keys.

### Budgets can follow the model instead of the user
[12:04](https://www.youtube.com/watch?v=s-glGHAa1a4&t=724s)
In Aperture, providers and their credentials are configured at the gateway. When a user or agent connects, the gateway identifies them and exposes the models they can use. Guercio gives the example of an unlimited budget for a cheap model and an extremely narrow budget for a frontier model. The user does not need to create another identity or configure a separate key for each provider. Putting the LLM layer in one place also makes it easier to change models or providers without changing every client. The same setup can be expanded across an organization.

### One gateway can centralize MCP authentication and permissions
[12:44](https://www.youtube.com/watch?v=s-glGHAa1a4&t=764s)
Aperture also acts as an MCP gateway. Administrators can configure allowed MCP servers and apply identity-based access rules. Guercio gives the example of allowing marketing to use Google Calendar and Gmail while giving engineering access to GitHub, with different read or write permissions where needed. Aperture can also inject OAuth for standard APIs and expose them as MCPs. Users can connect Cursor, Claude Code, Codex, or another agent framework to the same endpoint. If they are on the tailnet, authentication follows the user, agent, or tagged device, so switching tools does not require repeating authentication setup.

## Notable quotes
- "I would like to call ROI maxing right, we're not going to be token maxing, we're going to be ROI maxing." (05:14)
- "There's four things, right? There's the LLM or LLMs, there's sort of the data connector layer, there's the interface, and then the last one is sandboxes." (06:07)
- "You get unlimited budget with a cheap model and you get an extremely narrow budget with a frontier model." (12:12)
- "All of the authentication happens here." (14:03)
- "ROI maxing really is all about maximizing choice to prevent lock-in." (17:50)

## Tools & references mentioned
- Tailscale
- Aperture
- WireGuard
- TSNet
- Claude Code
- Codex
- Cursor
- MCP
- Anthropic
- OpenAI
- Vercel
- Amazon Bedrock
- Google Calendar
- Gmail
- GitHub
- Entra
- Okta
- Open WebUI
- LibreChat
- OpenClaw

## Who should watch
- Your team is spending heavily on AI tools and finance wants a clearer explanation of where the money goes.
- You are choosing models, MCP servers, agent clients, or sandboxes and want to keep those choices replaceable.
- You run agents in the background and need identity and logs to understand what they did after something goes wrong.

## Editor's note

Remy Guercio says logs should let teams inspect an agent session that failed to reach an answer, spiraled out of control, or behaved differently than expected. Kitaru records every model call and tool result in a session, then replays the agent against those same inputs and responses without touching real systems. That gives teams a way to rerun the failure after changing the model, prompt, or code.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Privacy First Enterprise AI: Building AI Agents that Never Leave Your Security Boundary](https://aietalks.com/talks/privacy-first-enterprise-ai-building-ai-agents-that-never-leave-your-security) (Steven Moon, Aech AI Inc., 07:10)
- [AI Agents Don't Read Your Policy Docs. They Hit Your APIs](https://aietalks.com/talks/ai-agents-dont-read-your-policy-docs-they-hit-your-apis) (, 17:50)
- [IT Admin for the AI Workforce](https://aietalks.com/talks/it-admin-for-the-ai-workforce) (Sarthak Aggarwal, Decawork, 16:17)
- [Gateways are All You Need](https://aietalks.com/talks/gateways-are-all-you-need) (Karan Sampath, Anthropic, 17:48)
- [AI Platform Engineering](https://aietalks.com/talks/ai-platform-engineering) (Patrick Debois, 28:18)