AI Engineer Europe 2026

Gateways are All You Need

Karan Sampath· Member of Technical Staff, Anthropic17:48

Loading slides…

Read the talk

Gateways Are All You Need

A shared MCP gateway lets teams build their own tools while centralizing identity, access policy, and secure connectivity—and keeping agent deployments independent of enterprise data.

From a talk by Karan Sampath

Before you start: Basic familiarity with MCP clients, servers, and tools will help; no prior gateway implementation experience is required.

Finding a server is not enough

An enterprise can find an MCP server, but can it tell who uses its tools, which calls fail, and who should be allowed to change anything? Working on enterprise and internal MCP deployments at Anthropic, Karan Sampath encounters this gap between server availability and operational readiness. MCP is an open standard originating at Anthropic, and its official registry provides a growing discovery surface. Sampath describes the registry at talk time as containing thousands of servers. As companies build more servers, however, discovery alone does not answer the questions that determine whether enterprises can actually use them.

Consider an observability MCP server. The whole company might need to inspect failures, while only selected people should change systems or update dashboards. That requires more than granting access to the server as a whole: permissions must distinguish tools and actions within it.

  • Observability: Identify who uses the tools, understand how they are used, and locate failures that need engineering attention.
  • Access control: Scope servers and individual tools to the appropriate users and groups, separating visibility from permission to mutate state.
  • Security: Assess whether a server can expose data or cause harmful actions against internal or external infrastructure. Then consider the other side of the connection: a potentially untrusted remote client requesting private enterprise data.

These concerns reinforce one another. Permission decisions need identity; investigating misuse needs visibility; safe access requires attention to both the server and the client. Sampath’s diagnosis is that enterprises recognize these as familiar API infrastructure requirements, but their MCP deployments have not yet made them routine.

Slide titled “Enterprise State of Play” with three illustrated columns covering MCP usage visibility, user access to servers, verification of server security, and remote client access to private servers.Open full source frame
Enterprise MCP challenges: observability, access control, and security.
0:150:40
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:15 · section reference included

When server creation outruns deployment

A registry remains useful, but its job is incomplete from an enterprise’s perspective. Finding a server does not supply authentication, access control, observability, or credential management. The protocol leaves room for that infrastructure; a catalog does not implement it for the organization.

Coding agents such as Claude Code make it easier for individual teams to build MCP servers. The next step is where progress stalls: a server cannot get deployed, or its tools cannot obtain the access they need. Security teams face a growing approval queue without enough visibility to make decisions efficiently. Leadership then sees ineffective agents, even though teams have already built the integrations those agents need.

The Bottleneck slide shows Infra, Knowledge Base, CRM, Analytics, and DevOps MCPs feeding into a central Security Review box, with an outgoing arrow labeled Approved.Open full source frame
MCP servers converge on a security-review bottleneck.

The bottleneck is organizational as much as technical. Reviewing every server as a separate infrastructure project overloads security teams, limits builders’ freedom, and leaves the company with only a handful of usable tools. The goal is to let teams develop independently while preserving organization-wide visibility. Restricting the available toolset also restricts what every agent can accomplish, so solving these deployment frictions has consequences beyond any one integration.

3:203:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:20 · section reference included

Approve the platform, then decentralize the tools

Once coding agents can help teams construct servers, tool definitions, and access-control structures, the scarce resource becomes a trusted path to deployment. Security teams should approve a shared platform within which teams can build. Sampath calls this establishing a root of trust: the organization makes a common infrastructure decision instead of repeatedly reconstructing the same security foundation for each server.

Sampath reports that this approach has expanded MCP adoption in both internal and external work. The benefit can spread across the organization because a useful server is reusable by many agents, not just the agent that motivated its creation. This is a qualitative account of compounding utility, rather than a measured growth law. The gateway is his proposed way to turn that shared-platform principle into infrastructure.

A gateway sits between MCP clients and a potentially large collection of MCP servers. It supplies shared authentication, authorization, observability, secure connectivity, and support for hosting and deploying new servers. Those responsibilities move into a common layer so that each new server does not have to implement them independently.

For a legal team, the remaining work is concrete: decide what a contract review should surface, how redlining should work, and when a contract should be escalated to another person.

ResponsibilityDomain serverShared platform
Contract workflowReview, redline, escalateProvide deployment support
AccessImplement domain operationsEnforce who may invoke them
OperationMaintain business logicTrack usage and support scaling

The legal team still owns the meaning of its workflow. It does not need to rebuild the machinery for identifying callers, controlling usage, or accommodating additional agents. That separation matters because the team may now be able to build the server itself, without handing every change to a separate technical team.

5:345:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:34 · section reference included

What belongs inside the gateway

There is no single mandatory gateway design. Sampath’s component list is neither exhaustive nor a requirement that every implementation contain every part. It describes the pieces that support the shared-platform goal:

ComponentResponsibility
Auth HandlerAuthenticate callers
RBAC EngineApply role-based access policy
Proxy RouterRoute requests to internal servers
Tunnel HandlerProvide secured connectivity
SubregistryCatalog internal MCP servers
ToolingHelp builders create and integrate servers

The routing boundary is particularly important: clients see the gateway, and internal servers treat the gateway as their trusted endpoint. The proxy is therefore more than a convenient address; it is the common entry point through which the organization applies its controls.

A gateway CLI makes this infrastructure usable by the people building servers—and by the coding agents helping them. A team can use that tooling to create a server, integrate it with the platform’s services, and then concentrate on the server’s business logic. The complete diagram combines those developer tools with authentication, role-based policy, routing, tunneling, and the internal registry.

Gateway diagram contains Auth Handler, RBAC Engine, Proxy Router, Tunnel Handler, Subregistry, and Tooling, connected to MCP clients and MCP servers.Open full source frame
Inside the gateway: six components between MCP clients and servers.

The investment pays off when those shared capabilities stop being repeated work for every team. Sampath hopes that the platform can remain relatively inexpensive to maintain, with agents helping build it, but low maintenance is an aspiration rather than an automatic property of adding a gateway. The durable benefit is a common place to improve infrastructure that many servers depend on.

8:288:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:28 · section reference included

Centralize identity, policy, and tool feedback

With that structure in place, the enterprise can connect its existing identity provider and support delegated identity for users and agents. Sampath anticipates that agents will need more explicit identities and scopes as their roles develop. A gateway gives the organization somewhere to express those distinctions, with one access-control surface for its agents and MCP servers and policies scoped to teams or individual users.

A small TypeScript policy example makes that separation concrete for the legal workflow. The operation names and roles below illustrate a central permission decision; the contract-review implementation remains elsewhere.

typescript

type Role = "legal-reader" | "legal-reviewer";
type Operation = "review-contract" | "redline-contract" | "escalate-contract";

const grants: Record<Role, ReadonlySet<Operation>> = {
  "legal-reader": new Set<Operation>(["review-contract"]),
  "legal-reviewer": new Set<Operation>([
    "review-contract",
    "redline-contract",
    "escalate-contract",
  ]),
};

function authorize(
  authenticatedRoles: readonly Role[],
  operation: Operation,
): "allow" | "deny" {
  return authenticatedRoles.some(role => grants[role].has(operation))
    ? "allow"
    : "deny";
}

const reviewDecision = authorize(["legal-reader"], "review-contract");
const redlineDecision = authorize(["legal-reader"], "redline-contract");
// reviewDecision: "allow"
// redlineDecision: "deny"

These are permission decisions, not executed contract operations. The roles must come from authenticated identity, and the gateway must enforce the decision before routing a request. Central policy makes it possible to change access without embedding a separate permission system in every domain workflow.

Observability should improve tools, not merely count calls. Usage metrics show which MCP servers are active, but the platform should also help teams understand their tool definitions and identify the tools on which important workflows depend. As MCP evolves and agents’ needs change, those observations guide where to adapt interfaces and invest engineering effort.

10:0010:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:00 · section reference included

Add clients without rebuilding every integration

Once a gateway exists, additional client surfaces can connect to the same shared layer. Sampath names Claude.ai, Claude Code, and Claude Cowork: each can reach the organization’s MCP servers through the gateway. The contrast is a hypothetical estate of forty servers configured unevenly for different clients. A common entry point reduces repeated integration work and makes the server estate less dependent on whichever client surface appears next.

The next benefit concerns sensitive data. Internal MCP servers may expose years of valuable enterprise work, and sending that data to another client raises legitimate questions about access and exfiltration. A gateway concentrates investment in encrypted connectivity and a defined trust boundary, making it easier to move beyond demonstrations that use only non-sensitive data. Encryption protects transport; it does not, by itself, prevent an authorized or compromised client from misusing data it receives.

11:2611:39
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:26 · section reference included

Iterate within shared standards

The legal team can now revise its workflow without repeatedly submitting the same infrastructure foundations for security review. That is the practical value of decentralized ownership: the people who understand the work can improve it quickly, within the approved platform’s scope. A gateway does not make every possible workflow change safe; it provides stable infrastructure so that unchanged foundations do not need to be reconsidered every time.

Shared infrastructure also gives the enterprise a way to encode its operating standards. New servers can use common primitives that reflect expected procedures, permitted tools, and prohibited behavior. Teams retain control over their domain logic while building against a consistent set of organizational expectations.

Credential flexibility follows the same pattern. A server may initially accept only one authentication type, while enterprise workflows need credentials associated with a user, a team, the company, or a service account. Gateway infrastructure can support selecting and substituting appropriate credentials for integrations that support them. This must not become blind token forwarding: MCP security guidance forbids token passthrough, so credential handling must respect the intended recipient and authorization boundary.

Sampath illustrates the scaling challenge with forty MCP servers serving populations that grow from tens to hundreds of thousands of agents. This is a hypothetical workload, not a reported capacity result. Rather than having every team independently maintain the entire request-handling surface, the gateway provides a common place to accept requests and distribute them to the appropriate servers. Backend capacity still matters; the architectural benefit is concentrating shared routing and scaling work where the organization can manage it coherently.

There are several routes to that infrastructure: open-source implementations, providers, and an in-house platform. Sampath describes enterprise gateway work as part of his own day-to-day role and offers implementation help, without prescribing a named product or a deployment recipe. The common requirement across those options is the trusted platform boundary, not a particular vendor.

12:5913:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:59 · section reference included

Keep the agent harness separate from the data layer

The longer-term purpose of the gateway is to separate the agent harness from where enterprise data lives. As agents multiply and new execution surfaces appear, their deployment choices should not force changes to the organization’s data structure or MCP server organization. Conversely, the data layer should not need to be designed around one particular harness. A stable gateway interface gives both sides room to evolve.

Sampath illustrates this with Claude Managed Agents, newly released at the time of the talk, and an internally deployed Claude Agent SDK application. Either deployment can connect through a gateway to enterprise MCP servers.

Agent deploymentWhat changesWhat can remain stable
Claude Managed AgentsHosted agent executionGateway and enterprise tool boundary
Internal Agent SDK applicationEnterprise-operated executionGateway and enterprise tool boundary

The enterprise can decide which agents run inside and which run outside without rebuilding its gateway layer. Shared connectivity does not imply identical client authentication behavior: in the current Agent SDK, the application handles interactive OAuth itself. That implementation distinction does not change the architectural separation.

In Practice slide compares Claude Managed Agents connecting to a gateway in a customer VPC with a local Claude Agent SDK connecting to a gateway and enterprise MCP servers.Open full source frame
Managed agents and a local Agent SDK connect through MCP gateways.

This separation lets an enterprise invest in gateway primitives that closely match its own procedures while retaining flexibility in agent design. The shared infrastructure should enable teams to build their own MCP servers, rather than make each team reproduce the platform plumbing. Secured gateway connections establish the common trust boundary; the harness remains free to change without reorganizing the data layer around it.

15:1115:26
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:11 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…