AI Engineer World's Fair 2025
What does Enterprise Ready MCP mean?
Read the talk
What enterprise-ready MCP requires beyond a working server
A goat-feeding API becomes a public service, then an enterprise product, exposing the identity, abuse prevention and delegated authorization work behind MCP.
From a talk by Tobin South
Before you start: Familiarity with API calls, authentication and basic cloud deployment will help; no prior MCP implementation experience is required.
From a chatbot to a network of agents
How do today’s enterprise tools map onto tomorrow’s AI systems? Start with a familiar path: a user talks to a chatbot, and the chatbot uses Model Context Protocol (MCP) to reach an external resource. That resource might provide database access, run a computation or supply a prompt. The interface connects the AI system to capabilities outside the model.
Now add an IT administrator who launches an asynchronous agent. Nobody needs to be sitting in a chat window while that workload runs, but it still needs access to secured internal tools through MCP. Add another connection: an employee’s chatbot calls an MCP server that queries an agent already running in the cloud. The enterprise problem now spans people, unattended workloads and services acting through other services. Each connection needs an answer to who is acting and what they may do.
Tobin South approaches this architecture from enterprise security work at WorkOS and, in his introduction, research on agent safety at Stanford. The practical question is how to supply the identity and authorization infrastructure that lets an agent move from a working experiment into a product an organization can adopt.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give an emotional-support bot a goat-feeding tool
The running example begins with an API that South presents as real: call it to feed goats, then watch them on a livestream. Build an employee emotional-support bot around that capability and give the model a tool for invoking it. The API and goats are the starting point; the expanding SaaS business that follows is an illustrative story. A single tool call is enough to get the first version working.
Why move that integration to MCP? South points to several benefits beyond the individual call:
- Shared ecosystem: integrations, providers and security tools can sit between the model and the resource.
- Standardization: a common interface gives model developers a consistent target for training and evaluating tool use.
- State management: retaining context across interactions can support management of the model’s interaction with a resource.
The last benefit needs a precise boundary. South describes a stateful connection, but the March 2025 transport specification makes Streamable HTTP session assignment optional. A logical session is neither a mandatory persistent connection nor an authorization guarantee. MCP supplies useful structure; the application still has to enforce its security policy.
There is also a lower-stakes reason to start: building an MCP server is an accessible way to experiment with new capabilities. The goat tool makes that appeal concrete. The harder work begins when someone else needs to use it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Move beyond localhost with explicit permissions
A local server proves that the model can reach the API. It does not yet prove that other people can safely use the service. South describes a common stopping point: an internal demo connects successfully, everyone sees that it works, and the project goes no further. The next milestone is authentication and authorization.
For the goat service, that means requiring login, restricting actions through roles or scopes, and reserving administrative privileges so ordinary users cannot overfeed the animals. Authentication establishes the caller’s identity; authorization determines which operations that identity may perform.
A minimal way to make that distinction concrete is to write down separate grants. This illustrative JSON uses separate permissions for feeding goats and changing feeding limits:
json
{
"roles": {
"employee": {
"permissions": ["goats:feed"]
},
"administrator": {
"permissions": ["goats:feed", "goats:limits:write"]
}
}
}
These are example application permission names, not MCP configuration keys. The server must check the relevant grant before performing the operation; putting a role in a record does not enforce it. Permission to feed also does not imply permission to bypass feeding limits.
For an internal deployment, South also suggests a VPC and NAT gateway. Network isolation can reduce exposure, but a NAT gateway is not an authorization mechanism. Private networking and application access checks address different boundaries, and the latter remain necessary for callers inside the network.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Publish the service and add payment
Suppose employees love the tool. The next step in the story is a public MCP server that people can connect to Claude or use from their own applications. Add Stripe payment rails, return a URL for the user to complete the payment interaction, and offer introductory credits. The conversational interface still depends on familiar product infrastructure: accounts, billing and an onboarding allowance.
Deployment does not require treating MCP as an entirely new category of compute. An MCP server is a normal workload that conventional cloud providers can host. Specialized hosting options may help, but getting a server online is only one part of making the public service sustainable.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Public adoption brings abuse and registration growth
The hypothetical service goes viral, and its free credits become an attack surface. Someone creates an account, spends the allowance, then creates another account and repeats. South recounts an unnamed AI vendor whose credits were being used to generate fan fiction, even though that was not the product’s intended purpose. An application backed by an AI API can become a convenient route to subsidized inference.
Bot blocking at signup and controls throughout the authentication stack address that account-cycling problem. Input validation addresses a different surface: what users send into the tool. South frames this as protecting the goats from prompt injection; validation belongs in that defense, but cannot by itself guarantee that a model will disregard malicious instructions.
MCP also changes the operational shape of client registration. South describes application dashboards becoming crowded with registrations. More precisely, MCP clients register as OAuth clients; the March 2025 authorization specification recommends dynamic client registration rather than requiring every MCP server to register itself as an application. An identity dashboard designed around a small set of manually created applications can become awkward when registrations arrive dynamically. Authentication and management tools need to accommodate that pattern as usage grows.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Enterprise adoption adds identity lifecycle and governance
Selling the agent—or the MCP server itself—to an enterprise follows a familiar SaaS path: single sign-on, lifecycle management and provisioning. South cites Block’s Goose as an example of internal agent adoption and describes provisioning access to both the client and MCP servers. His broader vision is that employees receive access to internal MCP resources through enterprise identity infrastructure and use chat as a routine way to automate work.
That identity foundation needs governance around the actual operations:
- Fine-grained access controls: check which resources and actions a caller may use, with checks fast enough for the workload.
- Audit logs: retain records that support investigation and incident response.
- Data-loss prevention: control sensitive information leaving the organization through MCP interactions.
South also invokes GDPR when discussing additional logging obligations for AI. That should not be read as a blanket GDPR rule for every AI workload: the explicit AI-specific provisions verified here are in the EU AI Act, including logging capabilities and retention provisions for high-risk systems. The applicable obligations depend on the deployment. The operational concern remains concrete: employees chatting with many servers create many opportunities to send information somewhere it should not go.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Which connections are already tractable?
At this point the service is enterprise-ready only with qualifications. The protocol is developing, and authenticating a server does not settle every question in the opening architecture. Returning to that diagram separates familiar integrations from the remaining agent-specific difficulties.
| Connection | Work required |
|---|---|
| User → chatbot | Familiar user login |
| AI client → MCP server | Client authentication and authorization |
| MCP server → external resource | Correct downstream scopes |
| Administrator → AI workload | Workload management |
| Tenant-local MCP server → resource | Internal integration and access configuration |
South treats these connections as implementable, even where integration remains awkward or MCP support is still developing. In particular, a server’s access to a downstream resource needs the right scopes; authenticating the upstream client does not automatically grant the right downstream permissions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Headless agents still need identity and human input
Remote asynchronous workloads make authentication harder to assemble correctly. The agent must connect without an interactive user, handle the registration arrangement and receive appropriate authorization. This was not an absence of application authentication in the historical specification: the March 2025 authorization document already discussed client credentials for application callers. South’s concern is the difficulty of getting the complete headless workflow and its access controls right.
A background agent may also reach a point where it lacks information and needs a person. South introduces elicitation as a new RFC at the time of the talk: a way to ask for additional input rather than continuing without it. Elicitation subsequently appeared in the June 18, 2025 specification as server requests for structured user input through a client. That mechanism does not, by itself, solve how an arbitrary background agent locates and contacts the relevant human.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Carry enforceable permissions across agent boundaries
The broader unresolved problem is what happens to permissions when one AI workload delegates to another. A task description can say what the receiving agent should do, but that description must not be the only thing limiting its authority. Scopes, access controls and the permissions of the receiving workload’s service account need to agree.
South criticizes reliance on natural-language instructions and model alignment in agent-to-agent interactions, using A2A as his example. This is a critique of delegated task permissions, not evidence that A2A lacked security mechanisms: its launch announcement already described authentication and authorization support. The difficult question remains whether the receiving agent has enforceable authority appropriate to the delegated task. Available cloud hosting does not solve delegated authorization. South identifies authorization and access control as the hardest remaining part of bringing these workloads into external enterprises.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Close the loop with an authenticated shirt purchase
South closes by inviting developers to build on the security stack, then offers a more tangible example: a shirt available only through MCP. The demonstration requires a computer and an MCP-capable client; he switches to Cursor. The purchase begins with setup rather than a conventional storefront.
The demonstrated sequence is:
- Copy the website-provided JSON into the editor’s MCP configuration.
- Confirm that the MCP server is enabled.
- Create an account to obtain authorized access.
- Ask the assistant to buy a shirt.
The conversational request comes after the client connection and account setup. It does not replace them.
A brief Wi-Fi interruption slows the interaction. The assistant then needs a mailing address and shirt size; South supplies an address and asks for a medium. He says the system recognizes his name, has authorized him and has performed a validation check. He also explains that signup bot blocking protects the shirt offer from abuse. Finally, he reports that the shirt has been purchased. The closing demonstration puts the earlier infrastructure behind a small, concrete transaction: connect a client, establish identity, gather the required input and complete an authorized operation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Historical OAuth requirements, client registration, token handling, and application-versus-user authorization flows.
Block explains its open-source agent framework, MCP integrations, and use by its engineers.
The original Agent2Agent protocol announcement outlines interoperability and enterprise security goals.
Further reading
- MCP transports and session managementDocumentation
March 2025 transport rules covering Streamable HTTP, optional sessions, streaming, and reconnection.
- EU AI Act: logging requirementsDocumentation
Primary legal text containing high-risk AI system record-keeping and log-retention provisions in Articles 12 and 19.
Updates since the talk
Structured requests for human input through an MCP client, including approval, refusal, cancellation, and safety constraints.
Read the complete timestamped transcript
- 0:00
[upbeat music] Thank you everyone for coming here.
- 0:16
I hope you're, uh, excited to figure out with me what enterprise-ready MCP means. Uh, I'm not sure a month ago e- people even fully understood what MCP meant. Um, so we're all on this journey together.
- 0:28
Um, but hopefully it should be fun. So I was chatting to a good friend and colleague who is, is giving a talk tomorrow on building MCP servers and what it looks like to build that out, and his question was:
- 0:39
how do the tools of today map to the AI systems of tomorrow? We already have some kind of kn- concept of enterprise-ready tooling and building tools for the enterprise and production.
- 0:50
What does it actually mean for MCP? And something I kind of, you know, wanna talk through today, chat with you guys. So, for a long time, for, you know, several years now, we've had the model of you are a user, you talk to an AI.
- 1:01
You talk to a chatbot, it does stuff. The AIs had tool calling, now they have MCP. This is the MCP logo, which is just a way of interfacing between the AI and an external resource of some kind to do something.
- 1:14
Right? It can just be a database access, it can be performing some complicated computation, it can be pulling in a prompt. There's lots of stuff in the MCP spec that frankly you should go and read.
- 1:23
There's more there than most people realize. We're also seeing workloads like this, where an IT admin spins up an asynchronous workflow, which is... we're gonna call an AI agent, which automates some process that is, you know, kind of headless and is going and doing a thing.
- 1:37
We're trying to manage that. That is then gonna use MCP to access external tools that might be secured, might be internal enterprise tools, which introduce some fun problems. I also, for the sake of this kind of diagram of what is the future gonna look like, wanna introduce this line here, just to throw some, some spanners in the
- 1:56
works, of users in a company using their chatbot, which makes a call to an MCP server, which then goes and queries an AI workload, an AI agent that's existing in the cloud performing some operation.
- 2:09
And so with this kind of diagram of what could happen, I want us to figure out what we need to fix to make this really useful and production-ready. Okay.
- 2:18
Why am I, why am I talking to you? Uh, I work for WorkOS, which is an enterprise security vendor, um, which I'll talk about in a second. I'm also a research fellow at Stanford working on safety for AI agents, and just finished a PhD where I got to wear this really funny, silly hat, um, just a couple
- 2:31
of months ago. Um, OpenAI, uh, uh, WorkOS is a, uh, enterprise security vendor that sells to all of the AI labs, because the AI labs do not wanna do the really painful, annoying work to scale the security and auth operations into the enterprise.
- 2:47
And so we've been thinking a lot about what it means to provide the glue that means people can build agents and then just seamlessly scale it and sell it to everyone.
- 2:55
And so I wanna just tell you all the answers today, whether or not you wanna use us. So let's go through the agent journey. We're all here trying to build agents.
- 3:03
Um, let's tell a, tell a story. So I found this great API, um, that you can query and it will feed a bunch of goats that you can then see on a live stream.
- 3:13
Um, this is a real API that you can go and use. And so naturally you do what anyone would do, and you're gonna build an emotional support bot for employees at a company to build a SaaS.
- 3:21
Um, and you give it tool use to query this. Now, this is fine 'cause it's a one-time query, but frankly, tool use kind of sucks. We've had it for years now.
- 3:31
Not as many people are using it. It's really painful. A lot of things go wrong, which is why the Model Context Protocol got invented. So why would you move to, to MCP?
- 3:40
One, there is this really robust ecosystem of tools and providers, security tooling, that lets you interface between the model and the resource to make things safe and reliable. It's also really good at providing standardization to the models, so the models are getting really good at learning how to use this, either through RL or just kind of, you
- 3:58
know, good evals on MCP usage. It also runs a stateful connection, which means you can do, you know, better security, better management, be- better context management in the way you're passing in to an AI model.
- 4:10
And maybe you're doing it just 'cause everyone's doing it and, and why not have some fun, right? It is genuinely quite fun to build an MCP server. You can make cool things out of it.
- 4:18
So what do we do? We make our local server, right? Hopefully, at some point everyone's had a little play with this. Uh, you tweet out, check out my local host.
- 4:26
Um, you know, try and get your friends to play with it. It's great. It's hacky. It's not particularly useful to anyone except yourself. You can build some fun local servers.
- 4:35
Uh, frankly, this is where we see a lot of people building MCP right now. It's an internal demo. You're gonna see if you can connect it to an API.
- 4:41
Cool, it works, and then we don't go much further than that.
- 4:46
And so kind of the next step where everyone has been talking about, a lot of discussion in the community is how do we do this really robustly, is just adding authentication and authorization to these workloads, which is truthfully right now the main thing you need to do.
- 4:59
These are links to docs that will help you do it. Uh, through there, you can come and chat with me and I will sit down with you anywhere in the world and help you build a really robust, secure MCP server and figure out some pain points.
- 5:10
Um, you should not have an external API that is unauthenticated, that has no access controls on it. Uh, things will go very wrong. So super simple. You make people log in, you scope, you have an admin privilege so that no one is feeding the goats too much.
- 5:27
You know, make sure goats are well-maintained and kept safe. Um, and maybe if you're doing this internally with an organization, you put in a VPC, you know, do a NAT gateway to make sure no one can access that they shouldn't.
- 5:37
But everyone, turns out, in your organization loves your goat emotional support tool, 'cause who wouldn't? And so you do what, what anyone would do. You, you say, "Let's make it public.
- 5:47
Let's make a public MCP server that people can add to their Claude, that people can build applications on top of. Let's add a Stripe in there to make sure they've got payment rails."
- 5:55
It just sends back a URL that you can call out to click things. It's pretty straightforward. Um, you give some users free credits 'cause, you know, this is how apps work, uh, and you put it on a cloud hosting solution.
- 6:04
Tons and tons of them are spinning up. I get ads and announcements about them every day.
- 6:09
Fundamentally, MCP servers are just a normal workload, which means a lot of the cloud hosting providers can support whatever you need to host. Um, and so there's, there's lots and lots that we can discuss there.
- 6:19
But you did this really well, and everyone loves goat feeding and emotional support, so you end up going viral. You've got a billboard on the highway. MrBeast tweets you out.
- 6:30
What happens? Now you end up with having way too much traction, right? You get free credit abuse on the signups. Uh, this is something that we see a, a ton of AI companies that we support happening, is AI companies give you some free credits to onboard you, but at the end of the day, they're just querying an
- 6:47
AI API, which means that folks will sign up for an account, abuse those free credits, and cycle back. One of the AI vendors, uh, that we work with, someone was using their free credits to write fan fiction stories, um, by just...
- 7:00
Uh, this is not an application designed for writing fan fiction, just because it- it's a convenient way to get free credits. And so you end up needing bot blocking on signups.
- 7:09
Um, you need kind of robust controls over the whole auth stack to make sure nothing goes wrong. Uh, you're gonna end up needing, uh, input validation so that no one prompt injection attacks your goats.
- 7:19
Gotta keep them safe. Uh, and then there's a lot of niche stuff that happens with MCP. So, uh, MCP servers dynamically register their clients with the server, which means if you have any developer admin dashboard, application dashboard, that's tracking the applications that you've created, they will suddenly be flooded with MCP servers 'cause of this weird choice in
- 7:40
how MCP servers register as applications. And so essentially, every auth stack you need, every, like, management tooling you need, needs to be adapted for MCP. And so this is something that we provide, but also, like, a bunch of other people are working on, and something to be conscious of, is if you scale, things will start going very
- 7:57
wrong. And so everyone loves your MCP server. That's super cool. Maybe it's just an AI, AI agent wrapping it, or you're selling the core MCP server. You wanna sell into enterprise.
- 8:07
What do we have to do? This is like a well-worn SaaS path that we're gonna go through. You have to do all of the boring stuff. You have to do the SSO, the lifecycle management.
- 8:16
You're gonna have to do provisioning. Um, Block, uh, are this super cool company, um, that developed Goose, and internally, they've been provisioning AI, like, access to this client, this chat client, as well as MCP servers.
- 8:32
And I really see a future where enterprises use SSO to provision access to a ton of internal resources exposed via MCP that then employees can chat with as a, you know, default way that employees are encouraged to use AI to automate workflows.
- 8:47
And so if you're going to sell into the enterprise, you end up needing all this, like, nitty-gritty stuff that really sucks. Fine-grained access controls that are highly performant, a really robust audit logs, um, for instant responses.
- 8:57
A lot of the regulations that exist right now, like GDPR, um, call out explicitly additional requirements on logging for AI workloads because the regulators like to regulate. And so your audit logs that exist normally have to fit a very specific set of requirements which are not well-supported widely.
- 9:15
And so something to think about as you scale these workloads. Um, and you need stuff like data loss preventions so that people aren't, like, uploading random things to MCP servers.
- 9:23
This becomes a significant risk when people are just chatting wildly with a ton of servers.
- 9:28
And so now you have an enterprise-ready server-ish, 'cause there are a lot of other questions to answer. Thi- this is a talk that was, was hidden to tell you the answers, but truthfully, the answers aren't entirely known yet, and the protocol is very rapidly developing.
- 9:44
And so this is the, the, the diagram we started off with. This stuff's super easy, right? How does a user log into an AI chatbot? Uh, done. We've solved that.
- 9:54
How do AI systems connect to MCP servers? This is something that's being worked on. It's pretty straightforward. We can do auth there. You can scan those QR codes from before, build it, and you have a production-ready MCP server.
- 10:05
MCP servers connecting to external resources is pretty straightforward. It's not too hard to do. Can be a bit annoying, but you know, you have to pass your scopes and do it properly.
- 10:14
Um, IT admins managing AI workloads, pretty straightforward. And in theory, you know, the other end of MCP servers existing in your tenancy connecting to resources, bit of a pain point but can easily be built.
- 10:28
There are lots of open questions still as to how we do this. Um, how exactly remote asynchronous workloads can do headless auth into MCP servers with dynamic client registration, uh, and make sure that is, you know, they have correct authorization controls.
- 10:43
It's actually super hard, and things keep going wrong along the way. Um, how these asynchronous workloads call out to relevant users. Uh, there is a, a new RFC in the MCP spec for elicitation.
- 10:57
So when your model doesn't know what to do, it knows that it should ask a human being, and this is becoming supported as part of MCP, that it can go and call out towards a user, um, and say, "Please provide additional input that you need because I'm missing details."
- 11:12
So stuff like this is actively developing, and nothing is stable. Um, and then there's this very broad question that we're running into with AI workloads, um, of, uh, passing scope between different AI workloads, passing access control between AI workloads, where if you have the A...
- 11:30
We're talking about MCP. If you're using A2A protocol, you are just telling an agent mostly in vibes what it should or shouldn't do and relying upon the alignment of that model to make sure it doesn't misbehave.
- 11:43
And so actually passing robust authorization, you know, scopes, uh, communicating access controls, making sure that service account, that that AI workload might be, has the correct access, turns out to be a huge pain point in doing this.
- 11:56
So frankly, the cloud vendors are, are mostly solving the cloud hosting. I think the authorization and access control element of this is the hardest part of putting this into external enterprise workloads, um, and a big thing that needs to be filled.
- 12:10
So if you want to build fun things, we are actively building out this entire stack to sell to AI companies and startups. Uh, and if you go to the docs, we can build some cool stuff together.
- 12:22
Um, everyone is building interesting things right now, and, you know, it's fun to get into the nitty-gritty and, and see what bugs occur. And then as a thank you for all listening to this fun talk, uh, you cannot use this on your phones, to be clear.
- 12:35
You can buy this shirt only through MCP. [laughs]
- 12:39
Uh, the instructions are on the website. Uh, very briefly, if you'd like to see... Let me see if I can get out of this, um, and go to Cursor.
- 12:47
You have to add the MCP server. There are many ways to do this, but the way I'd recommend is just going into one of your AI, um, editors, uh, typing in the JSON that the website will give you.
- 12:57
This is, like, the easiest way to add. You'll see that it's turned on. You'll need to make an account because authorization, access control, et cetera. Um, and then you can say, "Please buy me a shirt."
- 13:09
Um, and of course the Wi-Fi, um, will not work. [laughs]
- 13:15
Beautiful. We'll need my mailing address. Uh, [REDACTED:location_address], um, WorkOS, and I want a medium.
- 13:25
And it knows my name. It's authorized. It- it's done a validation check on me. We've got a bot blocker on the signup so that people can't abuse my shirts.
- 13:32
And you'll see right there that we purchased a shirt. So let's go back to Keynote. Um, scan it, add it to your computer if you want, um, and you guys can have a free, very nice MCP shirt, uh, that I would love to share around.
- 13:46
Thank you very much. [outro music]