Every MCP talk warns that exposing tools to an LLM is a new attack surface. True, but that's half the story. When we built a production MCP server, the more interesting outcome wasn't the new risk we introduced. It was the old risk we were forced to confront. Putting an LLM in front of real services means you can no longer trust the caller. You can't assume a well-behaved frontend passes the right tenant ID, or that it hides actions the user shouldn't see. That assumption, that the app in front handles authorization, is one a lot of backends quietly depend on. Building the server correctly meant injecting user permissions at the server layer and enforcing scoping on every tool. Doing that surfaced services that had never been properly authorized. The build became an accidental security audit of the existing application. This talk covers what that looks like in practice: why you inject identity and permissions at the server rather than trusting the model; why reusing your existing service layer is both an architecture and a security decision; which tools you should refuse to build; where human-in-the-loop and rate limiting belong; and why we had to split the server off shared compute once agents, not humans, became the primary traffic. If you're building or integrating an MCP server, this is the talk on what it will surface in the systems you already have.