Est.

Onboarding a Net New AI Team to MCP in Hours Using Reusable Access Primitives

A central MCP gateway lets new AI teams ship safely in hours.

· 9 min read
Cover illustration for “Onboarding a Net New AI Team to MCP in Hours Using Reusable Access Primitives”
Platform Teams · November 14, 2026 · 9 min read · 1,973 words

A unified MCP control plane for platform engineering teams combines a gateway, reusable team profiles, central authentication, tool-level permissions, and audit logs. This is how a net-new AI team can reach production in hours rather than weeks without rebuilding security plumbing. The platform team does the infrastructure work once, and each new team inherits a governed set of tools, resources, and prompts.

Why MCP became the default integration layer for enterprise AI teams

Anthropic open-sourced the Model Context Protocol in late 2024 so agents would have a standard interface to databases, SaaS tools, and internal systems [1][2][3]. OpenAI, Google, Microsoft Copilot Studio, and AWS added support within roughly a year of launch. That changed the starting point for new teams. They could use a shared protocol that major AI platforms supported without having to build a custom connector for every system.

MCP moved to the Linux Foundation’s Agentic AI Foundation in December 2025, backed by co-founders Anthropic, Block, and OpenAI. Anthropic participates in this cross-vendor infrastructure. The ecosystem now contains thousands of servers, with remote, vendor-hosted servers making up a large majority of the most-searched offerings. That deployment model lends itself to central governance, but a standard connection does not establish who should be allowed to use it.

The three server-side primitives that make reuse possible

MCP defines three server-side primitives, which are tools, resources, and prompts. Tools are executable functions controlled by the model. Each definition includes a machine-readable name, a human-readable title, a natural-language description, typed JSON Schema for inputs, an optional JSON Schema for outputs, and behavioral annotations. The definition explains more than how to call a function. It gives an agent context about what the function does.

Discovery makes those definitions useful across teams. During initialization, clients and servers negotiate capabilities by asking what each side can do. When an agent calls tools/list, it receives available tool definitions with their business context. A new team can therefore discover capabilities without commissioning a separate handoff for every connection.

Resources and prompts serve different actors in that exchange. Resources are data sources that the application controls and that URIs identify, so the agent can access the data without knowing how the system behind it is structured. Prompts are user-controlled reusable templates that let teams share tested interaction patterns. The practical boundary for reuse is straightforward. A capability that teams, models, or clients need to share belongs behind an MCP server, while native function calling is fine when it does not need to be shared.

What production deployments look like when primitives are shared at scale

Block runs more than 60 internal MCP servers across tens of thousands of employees in more than 15 job functions. A large majority of its engineers report saving several hours a week on daily tasks. Uber runs more than 1,500 monthly active agents across its internal services, with tens of thousands of agent calls each week. Its MCP gateway enforces authorization on every request. These deployments show that many teams can share access while central enforcement stays in place.

They do not, by themselves, establish an hours-long onboarding benchmark. The gateway pattern makes that target plausible. Instead of receiving a raw server URL, a team joins a profile containing the capabilities its role needs. Sales receives CRM read/write and Slack tools, Engineering receives GitHub, Jira, and CI tools, and Finance receives accounting read tools. The team starts with clear limits on what it can access, but those limits work only if it can still trust the primitives within them.

Why the same primitives that speed onboarding also widen the attack surface

Dynamic discovery lets an agent learn what is available at runtime, but it also gives server-supplied text influence over the agent. Tool descriptions are instructions. A server can change those instructions after approval without triggering another review. Unless the platform checks what changes, shared definitions can spread unsafe behavior along with the capabilities teams need.

MCP does not close that gap on its own. The specification has no native role-based access control model and does not require authorization. Servers also typically hold credentials for multiple downstream systems, so a compromised server can expose more than its own functions. Meanwhile, developers and non-developers add servers to Claude Code, Cursor, VS Code, and Claude Desktop configurations outside formal review. Without a complete inventory, security teams cannot even see the access they are expected to govern.

A profile cannot be treated as permanent approval for everything a server might later advertise or execute. It needs controls over the specific tools available, the credentials behind them, and the requests made during a session. Otherwise, easier onboarding simply makes unmonitored access easier to spread.

The concrete threats that exploit ungoverned MCP access

The Deadbugz campaign in August 2026 showed why a review at the start was not enough. A malicious MCP server called “productivity-suite” spread through public GitHub pull requests and behaved ordinarily for three tool calls. It then changed its instructions, directing the agent to collect SSH keys, AWS credentials, shell history, and Kubernetes configuration while hiding the activity from the user. Approval based on an apparently harmless first interaction could not address that change.

The Dolt MCP authentication bypass exposed a different failure. Versions 0.3.1–0.3.6 returned a 401 for invalid tokens but kept processing requests, so unauthenticated callers could run database tools with the server’s credentials. Version 0.3.7 fixed the flaw. Grafana MCP also accepted well-formed caller-generated session IDs, allowing tool use under its Grafana service account. Its second flaw, CVE-2026-19516, scored CVSS 9.1 and allowed a caller-controlled header to redirect requests to cloud metadata endpoints.

OX Security’s April 2026 disclosure, “The Mother of All AI Supply Chains,” identified command execution exposure in Anthropic’s official MCP SDKs for Python, TypeScript, Java, and Rust. The disclosure showed that STDIO passed parameters to the host operating system shell without sanitization. These failures cross several layers of the stack. OWASP’s MCP Top 10 includes tool poisoning, software supply chain attacks, command injection, shadow MCP servers, and context injection and over-sharing. Bugs need to be patched, but access controls must also limit what compromised software can reach.

The authentication foundation every MCP deployment needs before onboarding anyone

The platform team should establish authentication before assigning any team access. OAuth 2.1 with PKCE using S256 is the foundation for remote servers implementing authorization. The specification does not require authorization but says that HTTP-based implementations that support it should follow its authorization specification. STDIO servers should retrieve credentials from the environment.

Authentication must also be tested at the execution boundary. A rejected request must stop as well as return an error response. The Dolt incident makes that distinction concrete. Beyond token validation, Enterprise-Managed Authorization, or EMA, provides a stable MCP extension for central provisioning through an organization’s identity provider. During SSO, the client obtains an Identity Assertion JWT Authorization Grant, an IETF draft grant type, and exchanges it for an access token from the server’s authorization server.

EMA governs whether a user can connect a client to a server and at what scope. It does not inspect traffic after token issuance. Before onboarding, the platform team therefore needs an inventory covering developer machines, repositories, and CI, recording each server’s client, launch command or URL, version, and source package. Server allowlists, named approval owners, specific tool permissions, pinned versions, and update reviews establish the approved set. Secrets belong in environment variables or a secret manager, with configuration scans catching hard-coded tokens. A team-profile gateway can then turn that foundation into repeatable access.

How do platform teams give multiple AI teams MCP access without duplicating security plumbing?

Define profiles in the gateway. New teams get the profile for their role without having to work out every tool connection from scratch. The profile is the reusable access unit. Its credentials should be short-lived, provisioned just in time, and scoped to the task. An agent helping with expense reports needs access to the expense system.

Each server in a profile should receive its own scoped credential, because shared tokens extend the reach of a compromise. An orchestrator must not pass its credentials to sub-agents. Each sub-agent authenticates on its own with only the permissions it needs for its subtask, while behavioral identity checks test whether it is still acting within expected parameters. The gateway should capture the full request lineage, including the engineer, Oncall Agent, and Investigation Agent.

Runtime policies must enforce permissions at each tool call. Connection approval is not approval for every later action. Turn off automatic tool-call approval at least for write actions, using managed settings that users cannot override, and validate server-supplied URLs and hosts to restrict requests aimed at internal services or cloud metadata endpoints. With these controls in place, setup through a collaboration surface such as Slack can use the profile to pre-populate available tools. A new member reaches a working agent without rebuilding infrastructure.

The audit and logging architecture that makes governed onboarding provable

Log every tool call with its user, agent, server, tool, arguments, and result, and send those records to a SIEM. Prompt-only logging misses much of the execution path. Runtime inspection must also check tool descriptions, calls, and results because hidden instructions can come through content that the server supplies. That visibility supports investigation of a Deadbugz-style change after approval rather than leaving security with only the user’s original request.

OTEL tracing should record every hop across a multi-agent workflow so the audit trail matches what actually ran. Identity must remain attached to each action. SSO and SCIM support distinct identities, and each tool call outside the language model should be authorized with the acting identity attached. Human approval gates for high-impact or irreversible actions belong at the tool level. These controls let investigators connect an action to its actor, permission, and workflow.

Colorado SB 26-189 requires compliance records for agents materially influencing consequential decisions to be retained for at least three years from each decision, with the law effective January 1, 2027. EU AI Act Articles 12, 19, and 26(6) require high-risk systems to support automatic event recording over their lifetime, with logs retained for an appropriate period of at least six months. Retention alone cannot answer who did what. Continuously exporting short-lived vendor logs into a write-once archive that the customer controls keeps evidence from being changed or deleted and helps security teams approve quickly and investigate with confidence.

The order of operations for getting a net-new AI team to production in hours

First, inventory every server already running, including its version, source, and credentials. Do this before building profiles from existing deployments. Next, establish the central authentication foundation with OAuth 2.1 and PKCE for remote servers, EMA for SSO-based provisioning, and just-in-time credentials for each server in each profile. The platform team owns this work as a one-time setup.

Then define and test the gateway profiles. Map tools to roles, enforce server allowlists and tool-level policies, and test that requests stop running when they are rejected. Only then should the team lead or platform engineer assign the new team its profile. Before its first production tool call, activate logging, OTEL tracing, and SIEM integration. Audit cannot wait until after launch.

Finally, set rules for when each update needs another review. Server versions, descriptions, and who owns a package can change, so approval at the start is not enough. Version and behavior checks keep the profile tied to what was actually approved. This is ongoing platform work.

Hours-long onboarding means the new team spends its time learning what tools it can use and building agent logic. It does not mean the underlying controls took hours to build. Security and IT can approve quickly because the primitives are pre-vetted, credentials are scoped, and evidence is already flowing. The right way to use AI becomes the easy way because the approved path is ready before the team arrives.

Sources

  1. MCP Security Crisis: Systemic Design Flaws in AI Agent Infrastructure
  2. Enterprise-Managed Authorization: Zero-touch OAuth for MCP
Filed underPlatform Teams

More in Platform Teams