The architecture review for uw-assessment goes well until the last slide. The platform team has drawn the server, the gateway, the identity provider, the catalog and the tracing pipeline. A reviewer from identity and security governance asks one question per box: "Which of these is the standard, which is a product, and which is something we wrote? And what happens to us if it changes next quarter?"
Nobody can answer cleanly. The MCP specification is dated and normative. The OAuth version it cites is still a draft. The claims team's SDK follows the specification on its own schedule. The registry is in preview. The tracing names are marked "Development". The identity setup follows a vendor page that links an older protocol revision. Each fact is easy to find; together they decide how much of the design will stay still.
This reference chapter answers that review, one section per named item, each read on its own documentation on 2026-11-18. It deepens Sharing, Enterprise authorization and Observability. It names no product it did not read, ranks nothing and quotes no prices.
How to read the labels on this page#
A standard is a specification published by a standards body or by the MCP project as normative text, with MUST and SHOULD requirements, changed by dated revision or new document number. A tiny example: MCP revision 2026-07-28, or RFC 8707.
A community extension is an optional addition maintained by an open project outside the normative core; it promises only what its maintainers state. A tiny example: the official MCP Python SDK. Official MCP projects (SDKs, the Registry, extensions) carry this label because they are optional and versioned apart from the specification, not because they are unofficial.
A vendor feature is a capability of one company's product, documented and changed by that company. A tiny example: Microsoft Entra's documented way of protecting an MCP server.
The labels are this site's convention, not a ranking: they say what you can rely on and whom to ask when it changes. Claims inside each section also carry the lead-ins Normative, Ecosystem pattern and This site's recommendation.
Before AI. A Java team already does this for every dependency. The Servlet specification is a standard; Spring is an open-source project with its own release train; a cloud vendor's managed gateway is a vendor feature. Nobody confuses "Spring changed a default" with "the Servlet specification changed".
The table lists every item in section order; it takes the place of a lab, because the ecosystem changes too fast for a recorded interaction to stay true.
| Item | Label | Version or status read on 2026-11-18 |
|---|---|---|
| MCP specification | standard | revision 2026-07-28 (current) |
| JSON-RPC 2.0 | standard | last updated 2013-01-04 |
| OAuth 2.1 draft and cited RFCs | standard (one draft) | MCP cites draft -13; latest -17, not an RFC |
| OpenTelemetry GenAI and MCP conventions | standard, in development | status Development, no release |
| MCP Python, TypeScript, Java SDKs | community extension | Tier 1, Tier 1, Tier 2 |
| Official MCP Registry | community extension | preview |
| Organization catalogs and subregistries | your system; interface is a community extension | pattern |
| MCP gateways | ecosystem pattern; products are vendor features | no product read |
| Enterprise-managed authorization | community extension | Stable, keyed to 2026-07-28 |
| Microsoft Entra for MCP servers | vendor feature | page dated 2026-11-05 |
| A host that consumes MCP servers | vendor feature | Claude Code documentation |
Diagram: Where each item acts in one call · from the claims host to uw-assessment
Read left to right along one call. The host and its SDK build the request. Identity gives it a token. A gateway may pre-check it. The server, built on an SDK, authorizes and calls the domain service. The registry and the catalog sit before the call: they decide what the host knows about. OpenTelemetry names the spans at every hop. Click a box for its label and its limit.
- Before the call · finding servers
- Official MCP Registry: Metadata for publicly accessible servers under verified namespaces. No private servers; scanning left to others.
- Organization catalog: The insurer's source of truth. A private subregistry, if any, is generated from it.
- The caller's side
- Host (provider client): The application the person or agent works in. Decides how servers are configured, approved and authenticated.
- Identity provider: Issues the token whose audience is the MCP server. With enterprise-managed authorization, policy is set once at the identity provider.
- Platform edge
- Gateway (pattern): Rejects what any server would reject and counts calls per client. Never forwards the caller's token; never owns domain rules.
- Server side
- MCP server on an SDK: Python, TypeScript or Java SDK handles the protocol; the server authorizes every call and calls the domain service.
- OpenTelemetry spans: Span and attribute names shared across SDKs and gateways; trace context travels in _meta.
The map places each item where it acts in one call from the claims host to uw-assessment. Carry one point through the sections: the standards fix the wire and the token; everything else is a choice someone made and must keep current.
Standards · The MCP specification#
The normative text that defines how an AI application discovers and calls capabilities other programs offer. It solves the problem every page here starts from: without a shared contract, each host and server would invent its own call format.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | JSON-RPC 2.0; stateless, with version and client capabilities in every request's _meta; mandatory server/discover; resultType on every result; stdio and Streamable HTTP |
| Strengths | one vocabulary of methods and errors; a dated revision to pin; deprecated features kept at least twelve months (ninety days expedited) |
| Limitations | says it "cannot enforce these security principles at the protocol level"; no tool versions, catalogs or gateways; 2025-11-25 tutorials no longer apply |
| Integration and security | HTTP authorization per its authorization pages; no token passthrough; W3C trace context in reserved _meta keys |
| When plain code is better | one application owning data and agent: a typed function call (Start here) |
| Label | standard (normative) |
| Version and date verified | 2026-07-28 current, 2025-11-25 previous; 2026-11-18 |
| Primary sources | specification, versioning, changelog |
Minimum example (documented shape; the example's server answers this request shape):
{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_roof_assessment", "arguments": {"submission_id": "SUB-1004"}, "_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientCapabilities": {}}}}
Standards · JSON-RPC 2.0#
A small specification for remote procedure calls in JSON: a request names a method, a response carries a result or an error, an id ties them together. It solves framing, so MCP does not define its own.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | jsonrpc "2.0", method, optional params, id; a request without id is a notification and gets no reply; exactly one of result or error; codes -32700, -32600 to -32603, -32000 to -32099 |
| Strengths | tiny, stable, transport-neutral |
| Limitations | no authentication, no parameter schema; MCP narrows it (no null ids) and reserves -32020 to -32099 |
| Integration and security | application codes outside -32768 to -32000 (the example's -31403) |
| When plain code is better | inside one process there is nothing to frame |
| Label | standard (a published specification, not an IETF RFC) |
| Version and date verified | 2.0, last updated 2013-01-04; 2026-11-18 |
| Primary sources | JSON-RPC 2.0 |
Minimum example (documented shape): request, shortened response, notification.
{"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {"_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientCapabilities": {}}}}
{"jsonrpc": "2.0", "id": 1, "result": {"resultType": "complete", "supportedVersions": ["2026-07-28"]}}
{"jsonrpc": "2.0", "method": "notifications/tools/list_changed", "params": {}}
Client and server teaches JSON-RPC from zero.
Standards · OAuth 2.1 draft and the RFCs MCP cites#
The family of specifications by which a client obtains an access token for a protected resource. It solves "who is calling, for which resource, with which permissions" without the server handling passwords. Normative (MCP specification 2026-07-28): servers must publish RFC 9728 protected resource metadata, clients must send the RFC 8707 resource parameter, and servers must validate that a token was issued for them.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | RFC 9728 resource metadata; RFC 8414 server metadata; RFC 8707 resource (the token's audience); RFC 8693 token exchange; also RFC 6750, RFC 9207 |
| Strengths | mature identity providers; audience binding stops a CRM token working at the MCP server (UW-M04) |
| Limitations | OAuth 2.1 is an Internet-Draft: MCP cites -13 (28 May 2025), the latest is -17 (31 October 2026); Dynamic Client Registration is deprecated in MCP |
| Integration and security | bearer header only; PKCE with S256; issuer comparison; no passthrough |
| When plain code is better | stdio servers take credentials from the environment, as the specification says |
| Label | standard (RFCs are Proposed Standards; OAuth 2.1 is a draft) |
| Version and date verified | RFC 8707 (2020), 9728 (2025), 8414 (2018), 8693 (2020); 2026-11-18 |
| Primary sources | MCP authorization, RFC 9728, RFC 8707, OAuth 2.1 drafts |
Minimum example (documented shape, values from this site's example):
{"resource": "https://mcp.uw.insurer.example", "authorization_servers": ["https://idp.insurer.example"], "scopes_supported": ["uw.read"], "bearer_methods_supported": ["header"]}
Standards · OpenTelemetry GenAI and MCP semantic conventions#
OpenTelemetry is an open standard and toolset for traces, metrics and logs; its semantic conventions are agreed span and attribute names. They solve readability across hops: a trace through a Python host, a gateway and a Java server is only useful if all three name things alike.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | span name {mcp.method.name} {target}; kinds CLIENT and SERVER; mcp.method.name required; trace context in params._meta as traceparent, tracestate, baggage |
| Strengths | one naming scheme across SDKs; propagation matches MCP's reserved _meta keys |
| Limitations | moved to a separate repository with no release; status "Development"; still lists initialize and mcp.session.id, no 2026-07-28 in the parts read |
| Integration and security | tool arguments in spans are opt-in because they may be sensitive |
| When plain code is better | a single-process agent with application logs |
| Label | standard, in development |
| Version and date verified | Development, no release; 2026-11-18 (end of the GitHub page not read) |
| Primary sources | moved notice, semantic-conventions-genai |
Minimum example (documented shape; illustrative values):
{"name": "tools/call get_roof_assessment", "kind": "SERVER", "attributes": {"mcp.method.name": "tools/call", "gen_ai.tool.name": "get_roof_assessment", "jsonrpc.request.id": "3"}}
Observability maps these to the example's audit events; tracing as a discipline is at https://observe.sammuthu.com.
Official SDKs · MCP Python SDK#
An official SDK is a library in the MCP project's own organization that implements the protocol for one language. Ecosystem pattern: the SDK page lists Tier 1 TypeScript, Python, C#, Go, Rust, Ruby; Tier 2 Java; Tier 3 Swift, PHP, Kotlin. Tier 1 means a 100% conformance pass rate and new features before a specification release; Tier 2, 80% and within six months; no tier requires extensions such as Tasks; "SDKs adopt new protocol revisions on their own schedules." The Python SDK solves hand-writing transports and schemas in Python.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | class MCPServer (from mcp.server import MCPServer); decorators declare tools; schemas from type hints |
| Strengths | Tier 1; v2 implements 2026-07-28 and "serves both revisions at once" |
| Limitations | FastMCP renamed MCPServer, old import removed; WebSocket and experimental Tasks API removed; Tasks extension not implemented yet; no version number on the pages read |
| Integration and security | authorization stays in your code; two revisions served means two behaviors to test |
| When plain code is better | an agent calling its own service in-process |
| Label | community extension (official MCP project) |
| Version and date verified | v2, "the current stable release line"; 2026-11-18 |
| Primary sources | docs, what's new, SDK tiers |
Minimum example (documented shape; not run here; service is the assessment service, and the authorization checks a real server needs are left out):
# Documented shape of the MCP Python SDK v2; not run here.
from mcp.server import MCPServer
mcp = MCPServer("uw-assessment")
@mcp.tool()
def get_roof_assessment(submission_id: str) -> dict:
"""Return the PropertyAssessment of one submission's property. Read only."""
return service.get_roof_assessment(submission_id)
Official SDKs · MCP TypeScript SDK#
The TypeScript SDK implements MCP for Node.js and similar runtimes, where many host applications are written.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | packages @modelcontextprotocol/server, @modelcontextprotocol/client; class McpServer; registerTool with a Zod v4 schema |
| Strengths | Tier 1; targets 2026-07-28; v1 gets fixes for at least six months after v2 |
| Limitations | the README does not say whether v2 serves 2025-11-25 clients; v1 users change package names |
| Integration and security | the schema is generated from code, so a test must pin it (Java and SDKs) |
| When plain code is better | a Node service whose callers are other services keeps its HTTP contract |
| Label | community extension (official MCP project) |
| Version and date verified | v2 released 2026-07-27; 2026-11-18 |
| Primary sources | typescript-sdk |
Minimum example (adapted from the README to the roof lookup; service is the assessment service; not run, not compiled):
import { McpServer } from '@modelcontextprotocol/server';
import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';
const server = new McpServer({ name: 'uw-assessment', version: '2.0.0' });
server.registerTool('get_roof_assessment',
{ description: 'Return the PropertyAssessment of one submission.', inputSchema: z.object({ submission_id: z.string() }) },
async ({ submission_id }) => ({ content: [{ type: 'text', text: JSON.stringify(await service.get(submission_id)) }] }));
await server.connect(new StdioServerTransport());
Official SDKs · MCP Java SDK#
The Java SDK implements MCP for the JVM, maintained with Spring AI; it serves enterprise teams like the claims team.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | Maven io.modelcontextprotocol.sdk:mcp; sync and async APIs; stdio and Streamable HTTP (JDK HttpClient, Servlet API) |
| Strengths | modern 2026-07-28 and legacy 2025-11-25 and earlier in one module; Java 17+ |
| Limitations | Tier 2; Spring transports come from Spring AI (2.1+ for the modern revision), not the SDK |
| Integration and security | authentication and authorization in servlet filters in front of the transport |
| When plain code is better | a Spring service with only service callers keeps its REST controller |
| Label | community extension (official MCP project) |
| Version and date verified | mcp-core 2.2.0 in the API reference; 2026-11-18 |
| Primary sources | Java SDK docs |
Minimum example (documented coordinates; not run here):
<dependency>
<groupId>io.modelcontextprotocol.sdk</groupId>
<artifactId>mcp</artifactId>
<version>2.2.0</version>
</dependency>
Java and SDKs compares the three SDKs' schema sources and validation; this page does not repeat it.
Registries · The official MCP Registry#
In its own words, "the official centralized metadata repository for publicly accessible MCP servers". It solves public discovery: one place where a server's name, location and launch instructions sit under a verified namespace.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | a server.json per server version; read-only REST API under /v0.1/servers, cursor-paginated; metadata immutable except status |
| Strengths | namespace proof by GitHub, DNS or HTTP challenge; an OpenAPI interface other registries can implement |
| Limitations | "currently in preview"; no private servers; not for hosts to consume directly; does not verify control of a remote URL |
| Integration and security | scanning delegated to package registries and aggregators: listed is not vetted |
| When plain code is better | for private servers it is not an option; the catalog is the source |
| Label | community extension (official MCP project, preview) |
| Version and date verified | preview; 2026-11-18 |
| Primary sources | about, aggregators |
Minimum example (documented read API; not run here):
curl -s "https://registry.modelcontextprotocol.io/v0.1/servers?limit=10"
Sharing shows a server.json for uw-assessment and why the public registry would refuse it.
Registries · Organization catalogs and subregistries#
The catalog is the organization's record of approved capabilities (Sharing is its home). A subregistry is "an aggregator that also implements the OpenAPI spec defined by the MCP Registry". Together they solve private discovery while ownership stays in the catalog.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | the registry's OpenAPI interface; own data under _meta with the subregistry's key |
| Strengths | registry-aware hosts work unchanged; the organization adds its own fields |
| Limitations | the official codebase "is not designed for self-hosting"; entries describe servers, not tools |
| Integration and security | discovery is not authorization: a token with the right audience and scopes is still required |
| When plain code is better | a few servers and hosts: one reviewed configuration file per host |
| Label | the catalog is your system; the interface is a community extension |
| Version and date verified | pattern from the registry documentation; 2026-11-18 |
| Primary sources | aggregators |
Minimum example (the _meta key pattern is documented; this key and its fields are this site's illustration):
{"_meta": {"example.insurer/catalog": {"owner_team": "property-risk-data", "risk_tier": "medium", "approved_scopes": ["uw.read"], "state": "monitored"}}}
This site's recommendation: generate the private registry from the catalog, never the reverse.
Gateways · MCP gateways as a pattern#
An MCP gateway is a proxy in front of MCP servers that applies shared policy (Enterprise authorization is the term's home). It descends from the API gateway: a reverse proxy that applies cross-cutting policy such as authentication, routing, rate limits and logging to HTTP APIs before requests reach the services. It solves applying one policy to many servers and teams.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | no protocol role; Normative (MCP specification 2026-07-28): Mcp-Method and Mcp-Name headers mirror the body so infrastructure can route without parsing it |
| Strengths | one place for token pre-checks, per-client limits, routing, per-consumer views (Advanced MCP) |
| Limitations | cannot decide what needs domain data (SUB-2001 belongs to commercial-east); must respect cacheScope private; one more hop |
| Integration and security | bound by the no-passthrough rule; never the home of domain rules |
| When plain code is better | one server, few hosts: checks and limits in the server |
| Label | ecosystem pattern; each product a vendor feature |
| Version and date verified | no product documentation read, so none named; 2026-11-18 |
| Primary sources | Streamable HTTP, security best practices |
Minimum example (illustrative policy, not any product's format):
# Illustrative gateway policy for uw-assessment; not a real product's configuration format.
route: https://mcp.uw.insurer.example
reject_before_server: [missing_token, wrong_audience, expired_token]
rate_limit_per_client:
claims-assistant: {bucket: 3, refill_per_s: 1}
analytics-jobs: {bucket: 2, refill_per_s: 1}
leave_to_server: [scope_per_call, principal_type, tenant]
forward_caller_token: false
Identity · Enterprise-managed authorization#
An official MCP extension, io.modelcontextprotocol/enterprise-managed-authorization, that "enables organizations to control MCP server access centrally through their existing identity provider (IdP)". It solves per-user, per-server consent and one-by-one offboarding.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | the client exchanges the SSO assertion (RFC 8693) for an ID-JAG, presents it with the jwt-bearer grant, receives an audience-restricted token |
| Strengths | central policy; no consent page per server; revocation at the identity provider "immediately across all MCP clients" |
| Limitations | ID-JAG is an Internet-Draft (-06); "implementations track different draft revisions"; issued tokens live until expiry |
| Integration and security | opt-in per request; the server's own checks do not move; vendor table "not comprehensive" |
| When plain code is better | few users, one server: standard MCP authorization |
| Label | community extension (official extension, Stable) |
| Version and date verified | Stable, keyed to 2026-07-28; 2026-11-18 |
| Primary sources | extension docs, ID-JAG draft |
Minimum example (documented shape): the client's declaration.
{"_meta": {"io.modelcontextprotocol/clientCapabilities": {"extensions": {"io.modelcontextprotocol/enterprise-managed-authorization": {}}}}}
Enterprise authorization walks the flow step by step.
Identity · Microsoft Entra, as documented#
Vendor feature (as documented on 2026-11-18): an Entra Agent ID page opens "An MCP server is an OAuth 2.0 protected resource. Register the server as an API in Microsoft Entra ID, publish protected-resource metadata, and validate each access token before processing an MCP request." It solves integration for workforces already in Entra.
| Template | As documented on 2026-11-18 |
|---|---|
| Protocol or data model | app registration, Application ID URI, delegated scopes; metadata resource must match the expected aud; server https://login.microsoftonline.com/<tenant>/oauth21/2026-08 |
| Strengths | maps onto the MCP steps; 401 for a missing or invalid token, 403 without scope or role |
| Limitations | v2.0 access tokens only; links MCP revision 2025-06-18; CIMD support in public preview; authorized-party claim and downstream flow not described |
| Integration and security | validate signature, issuer, audience, lifetime, tenant, client, permissions; downstream, a token "issued for this downstream API" |
| When plain code is better | not that choice: the server validates Entra tokens either way |
| Label | vendor feature |
| Version and date verified | ms.date 2026-11-05; 2026-11-18 |
| Primary sources | Secure an MCP server with Microsoft Entra ID |
Minimum example (the page's metadata shape, this site's host name):
{"resource": "https://mcp.uw.insurer.example", "authorization_servers": ["https://login.microsoftonline.com/<tenant-id>/oauth21/2026-08"], "scopes_supported": ["mcp.access"], "bearer_methods_supported": ["header"]}
Enterprise authorization maps Entra's steps row by row.
Provider clients · A host that consumes MCP servers#
A provider client here is a host from a model provider or tool vendor that connects to MCP servers for a user: the MCP host of What MCP is. Every host decides, outside the protocol, how servers are configured, approved and authenticated. One host's documentation was read, Claude Code's, as an instance of the role, not a recommendation.
| Template | As documented on 2026-11-18 (Claude Code) |
|---|---|
| Protocol or data model | HTTP (recommended), SSE (deprecated), stdio; also a WebSocket configuration, outside the specification's two standard bindings |
| Strengths | scopes local, project (shared .mcp.json), user; OAuth 2.0 for remote HTTP servers; managed configuration with allowlists and denylists |
| Limitations | managed-configuration details on a page not read; behavior changes with vendor releases |
| Integration and security | "Verify you trust each server before connecting it."; approval prompt before project-scoped servers |
| When plain code is better | an unattended pipeline calling one service |
| Label | vendor feature |
| Version and date verified | 2026-11-18 (end of the page not read) |
| Primary sources | Claude Code: MCP |
Minimum example (documented command form; not run here):
claude mcp add --transport http uw-assessment https://mcp.uw.insurer.example/mcp
For any host, ask: can the organization restrict which servers users add, does it send the resource parameter, and does it show the user a write before it happens?
In a coding agent. A coding agent is a provider client too, and its configuration scopes are this page's labels in miniature: a server in a repository's shared.mcp.jsonis the team's decision and needs approval before first use; a user's own server is personal; a managed list is policy. A repository server withread_fileis low risk; one that canopen_pull_requestbelongs only in the managed list. Harness Engineering covers the runtime that holds these connections.
Diagram: Three labels across four layers · what you can rely on, and who you ask when it changes
Rows are the layers of an MCP platform. Columns are the three labels this page uses. Read across a row to see which part of that layer is a standard, which is an optional community extension and which is one vendor's feature. The standards column is the shortest: most of a platform is choices that someone must keep current.
- Wire
- MCP 2026-07-28 + JSON-RPC 2.0: The dated specification and the framing it builds on. Changes by revision, with a deprecation policy.
- Official SDKs, Tasks: Optional libraries and extensions maintained by the MCP project, versioned apart from the specification.
- Host transport options: What a given host supports and how it is configured is the host vendor's choice.
- Identity
- OAuth RFCs + 2.1 draft: RFC 9728, 8707, 8414, 8693 are Proposed Standards; OAuth 2.1 is an Internet-Draft.
- Enterprise-managed authorization: Central policy at the identity provider, resting on the ID-JAG Internet-Draft.
- Microsoft Entra setup: One vendor's documented steps for protecting an MCP server; links an older MCP revision.
- Discovery
- server/discover: The only discovery the specification defines: what one server supports. Finding servers is outside it.
- Official MCP Registry: Public metadata repository with an OpenAPI interface that subregistries may implement.
- Marketplaces, managed lists: Aggregators and hosts add curation and allowlists on top; each is that vendor's feature.
- Telemetry
- W3C trace context in _meta: traceparent, tracestate and baggage are reserved _meta keys in the MCP specification.
- OpenTelemetry MCP conventions: Agreed span and attribute names, in a separate repository with no release yet.
- Tracing backends: Where traces are stored and queried is a product choice; no product is named on this page.
What goes wrong when the labels are missing#
| Mistake | What happens |
|---|---|
| A draft treated as final | code pinned to OAuth 2.1 draft 13, or an ID-JAG library on another revision |
| A preview treated as infrastructure | the registry resets data and an onboarding script breaks |
| An SDK treated as the protocol | a Tier 2 gap shows up in production |
| A vendor page treated as the specification | a 2025-06-18 setup is copied into a 2026-07-28 server |
| A gateway treated as the authorization | the server stops checking the tenant, and SUB-2001 leaks |
Security and governance notes#
Security note. Every item here moves trust somewhere: an SDK's parser, a registry's namespace check, a gateway's token check, an identity provider's policy, a host's approval prompt. None replaces the server's per-call authorization. A protocol standardizes the call. It does not grant the permission.
Governance note. Keep a dependency record per item: label, version or draft revision, date verified, owner, and the trigger for re-review (a new MCP revision, a draft update, the registry leaving preview, a vendor page change). That record is what the reviewer in the opening asked for.
What this is not. Not a product directory or a ranking, and not a tutorial for any item. Tool schemas and the tool loop are at Tools Engineering; tracing as a discipline at https://observe.sammuthu.com; SDK schema behavior at Java and SDKs.
Checklist for Monday#
| Check | Pass when |
|---|---|
| Labels | every component is labelled standard, community extension or vendor feature, with an owner |
| Revisions and drafts | each server's MCP revision and each draft dependency's revision are recorded |
| Preview | nothing in production needs the public registry to be up or stable |
| Gateway | the gateway-versus-server split of checks is written down; the server authorizes every call |
| Identity and hosts | identity setup checked against current MCP pages; hosts limited to approved servers |
Exercises#
- The claims team wants a gateway product because "it does MCP authorization". Which checks may it take over, and which stay in
uw-assessment? - Your identity provider's guide links MCP revision
2025-06-18. What do you check before following it for a2026-07-28server? - A developer proposes replacing the catalog with the public registry plus an "approved" tag in a fork. What is wrong?
AnswersOne line each
- It may reject what any server would reject (no token, wrong audience, expired, over the rate limit); scope per call, principal type and tenant need domain data and stay in the server.
- Compare each step with the current authorization pages: protected resource metadata, the
resourceparameter, audience validation, client registration (DCR is deprecated in2026-07-28) and no passthrough downstream. - The public registry accepts no private servers, its codebase is not designed for self-hosting, and it describes servers, not tools, so owners, scopes and risk tiers per tool would be lost; keep the catalog and generate any registry from it.
Why this site's example is not built on an SDK, and when yours should beA teaching subset shows the wire; a production server needs conformance
The example's server and client are a teaching subset of revision 2026-07-28, written from the specification with the standard library. That choice serves one purpose: every message is visible, and no SDK abstraction hides a check. It has a price the example states plainly: it is not conformance tested, and it leaves out SSE streams, subscriptions, pagination, multi round-trip requests, the Tasks extension and the real OAuth flow.
A production server should start from an SDK for the same reason a production HTTP service starts from a framework: framing, transports, header validation and error shapes are where subtle incompatibilities hide, and the SDK tiers measure exactly that against a shared conformance suite. The tier page's numbers are the useful ones: Tier 1 at a 100% pass rate, Tier 2 at 80%.
Writing your own protocol layer is defensible in three cases: a language with no official SDK at the tier you need, an environment where the SDK's dependencies are not allowed, or a very small surface (one tool, stdio only) where the protocol code is shorter than the SDK integration. In each case, run the official conformance suite against your server and record the result in the catalog entry, as you would for an SDK. Whatever you choose, the domain rules stay in the domain service; neither an SDK nor a hand-written layer should own them.
Questions to ask any gateway productA vendor-neutral checklist, derived from the specification's rules
No gateway product was read for this page, so none is named. These questions come from the rules the specification and this site rely on, and any product's own documentation should answer them before adoption.
Does it speak revision 2026-07-28: per-request _meta, no protocol sessions, server/discover, and the Mcp-Method and Mcp-Name headers? A gateway built for 2025-11-25 may depend on Mcp-Session-Id, which the current revision removed.
What does it do with the caller's token? It may validate it; it must not forward it to a service that would accept it as its own. If it obtains downstream tokens, by which grant, with which audience, and is the original principal recorded?
How does it cache lists? A tool list filtered by authorization is cacheScope private; a gateway that caches it across tokens shows one team's tools to another.
Can it hold back tools that are new or changed since a consumer's approval, using fingerprints, or only filter by scope? The second is not enough on a dynamic catalog (Advanced MCP).
What does it record? An audit event per call with principal, decision, sanitized arguments and correlation id, in a store the platform owns (Observability), and trace context propagated through _meta.
How does it fail? If the gateway is down, can the platform bypass it safely, or does every team stop? Who is on call for it?
And what stays in the server? Write down, per check, whether the gateway, the server or both perform it. The server must keep scope, principal type and tenant checks regardless.
Building on drafts, previews and Development conventionsFive moving parts under one platform, and how to keep them from moving you
As read on 2026-11-18, five things under the insurer's platform are not finished standards. The OAuth 2.1 document is at draft revision 17 while MCP cites revision 13. The ID-JAG format behind enterprise-managed authorization is at draft revision 06, and the extension's docs say vendors track different revisions. The OpenTelemetry MCP conventions have status Development, no release and still describe the 2025 protocol model. The public registry is in preview. And the Tasks extension is Beta on the extensions overview.
That is normal for a young ecosystem, and it does not mean waiting. It means isolating each moving part behind a seam you own. Put token validation behind one module whose tests pin the draft behavior you rely on. Pin attribute names in a small mapping layer, so a renamed OpenTelemetry attribute is one change. Treat the registry as a source to copy from on a schedule, never as a runtime dependency. Gate any Beta extension behind a catalog flag per server.
Then give each part a re-review trigger in the dependency record: a new draft revision, a convention release, the registry's general availability, a stage change. The MCP specification itself has the clearest rule of the set: deprecated features stay at least twelve months, or ninety days under the expedited exception. Nothing else on this page publishes a window like that, which is a reason to watch the others more closely, not less.
Registry entries and the server supply chainWhat a namespace proves, what it does not, and what to check before connecting
The registry's namespace check proves one thing: the publisher controls the GitHub account or domain in the server's name. For a package, the registry also checks a back-reference (an mcpName in package.json for npm, an mcp-name: line in the README for PyPI). For a remote server, the quickstart says the registry "does not verify that you control the remote URL". Security scanning is left to package registries and aggregators.
So a public entry is a pointer with a verified name, not a reviewed server. Before any host in the organization connects to one, treat it as a third-party dependency: pin the package version or the remote URL in the catalog, fingerprint the tool definitions at approval (Threat model), give it the narrowest scopes and no access to sensitive data, route it through egress control, and assign an owner who watches its releases. Registry metadata is immutable except its status, which helps: a version you approved will not be rewritten in place, but a new version needs a new review.
In one breath#
An MCP platform stands on a few standards (the MCP specification 2026-07-28, JSON-RPC 2.0, the OAuth RFCs) and on many things that are not finished or not standard: an OAuth 2.1 draft newer than the one MCP cites, Development-status tracing conventions, official SDKs with tiers and their own schedules, a registry in preview, a Stable extension resting on a draft grant, vendor pages that link older revisions. Label each one, record its version and date, and give it an owner and a re-review trigger. Then use products where they remove work, and keep the per-call authorization in the server, where the domain data is.
The insurer now has the protocol, the controls, the advanced patterns and a labelled map of what it can build them from. What it does not yet have is one picture that puts all of it together: the assessment service, the MCP adapter, the gateway, identity, the catalog, audit and the underwriter's decision path, with four teams on it and an owner for every box. That is Reference architecture.