Why this matters: Make the interoperability decision before choosing an SDK. Then design an explicit capability contract, a trust and authorization boundary, and an era-aware migration policy. For new MCP endpoints, prefer the 2026-07-28 stateless model where its constraints fit; retain legacy support deliberately, temporarily, and with observable fallback behavior.

What you will be able to do
- Distinguish a reusable MCP capability boundary from a tightly coupled direct API boundary.
- Explain the practical differences between the 2026-07-28 stateless era and initialize-era legacy compatibility.
- Classify Active, Deprecated, and Removed features and choose a migration response.
- Create a dual-era compatibility policy that accounts for SDK-specific defaults, probes, fallback, and opt-in behavior in evidence reviewed here (TypeScript, Python, Go, and C#).
1. Frame the integration boundary before implementing it
Decision brief — do not begin with “Should we expose a tool?”
Atlas Procurement has a tempting shortcut: expose its existing POST /refresh-vendor REST operation as an MCP tool and let any host call it. That would make the server interoperable, but not necessarily safe, supportable, or even the right boundary. A model may propose a refresh in text; the host application decides whether to present that option, gather user approval, and attach user identity. The MCP client serializes the protocol request. The MCP server validates the schema, caller authorization, and business preconditions. A deterministic application service performs the refresh, records an idempotency key, and verifies the resulting state. The external vendor-data provider is outside MCP and may fail, rate-limit, or charge money.
Frame the decision as: Which party owns the reusable capability contract, and which party owns user trust and action approval? MCP is strong when Atlas wants a capability contract that several compatible hosts can discover and invoke without each host receiving a bespoke SDK integration. A direct API remains stronger when one tightly coupled Atlas application owns both caller and backend, the operation is a small internal implementation detail, or the necessary trust model cannot safely be expressed through a host-mediated capability call.
| Choose MCP when | Choose a direct API/workflow boundary when |
|---|---|
| Multiple compatible hosts need the same stable capability; the server has independent ownership and release cadence; tool/resource schemas are reusable; interoperability is a product goal. | One application controls both ends; the call is a narrow backend implementation detail; a bespoke workflow needs rich transactional semantics; or caller identity/approval cannot be reliably propagated and enforced. |
Standardization does not turn a capability into a safe authorization boundary. A host’s model output is untrusted input, and an MCP server must not infer that model-generated text represents user approval.
2. Separate modern, legacy, deprecated, and removed behavior
Current-spec checkpoint. As of September 10, 2026, 2026-07-28 is the current stable dated MCP specification. The official project’s release material identifies it as the general-availability release, and the official releases page lists no newer stable dated specification. The earlier 2026-07-28 RC is not the target for a production compatibility policy. ([github.com](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/blog/content/posts/2026-07-28-spec-ga/index.md?utm_source=openai))
The modern 2026-07-28 era removes the protocol-level initialize/initialized exchange and the Mcp-Session-Id header. Each request carries protocol version and client capability information in reserved _meta keys; server/discover is an optional request for clients that want capability information in advance. This permits a request to be handled by any suitable replica behind ordinary load balancing, provided your own application state is represented explicitly—for example, by a server-minted opaque job handle passed as a regular tool argument. ([github.com](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/blog/content/posts/2026-07-28-spec-ga/index.md?utm_source=openai))
Contrast this with the legacy initialize era, through 2025-11-25: initialize-based negotiation and potentially session-oriented transport behavior remain relevant only for compatibility. Do not copy legacy assumptions into a modern contract. In particular, a server must not infer a client’s capabilities from an earlier request in the 2026-07-28 model; modern requests are self-describing.
Lifecycle vocabulary matters. The formal policy uses Active, Deprecated, and Removed. Deprecated means support may remain for compatibility, but new designs should choose the replacement; Removed means a client must not rely on it for that revision. The policy establishes a minimum twelve-month deprecation window. Roots, Sampling, and protocol Logging are Deprecated in 2026-07-28. DCR is deprecated in favor of Client ID Metadata Documents, but remains available for backward compatibility where an authorization server lacks that newer mechanism. ping is removed for 2026-07-28 and should not be a modern health-check foundation. ([github.com](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2026-07-28/changelog.mdx?utm_source=openai))
3. Specify a capability contract and its trust boundary
Draw the request path before you write a tool handler. MCP messages are JSON-RPC 2.0 requests, responses, and notifications carried over an MCP transport. The protocol provides the envelope and capability contract; it does not make the model the caller of record or replace your application authorization system.
For Atlas, define a read-only tool separately from a consequential action:
| Capability | Illustrative input contract | Server enforcement | Output contract |
|---|---|---|---|
| vendor_risk_summary | { vendorId: string, includeEvidence?: boolean } | Validate identifier; authorize read scope for that vendor; redact restricted evidence. | Structured risk band, evidence references, freshness timestamp, warnings. |
| request_vendor_refresh | { vendorId: string, reason: string, idempotencyKey: string } | Validate format and tenant; require refresh scope and explicit host approval assertion; deduplicate key; enforce rate/budget policy. | Job handle, accepted state, audit correlation ID; never claim completion until verified. |
The model can suggest request_vendor_refresh; it cannot be the security control. The host/application logic should display the impact—cost, vendor, and reason—obtain required approval, and invoke the MCP client with an authenticated principal. The server independently verifies token audience, issuer, scopes, tenant binding, and approval claim or transaction context. Validate tool inputs and external-provider responses against schemas; treat retrieved vendor notes and documents as untrusted content, not instructions for privileged actions.
For OAuth authorization response handling, issuer identification is a concrete anti-mix-up control: RFC 9207 defines the iss response parameter as the authorization server’s issuer identifier. MCP’s 2026-07-28 release specifically calls out RFC 9207 issuer validation hardening. ([rfc-editor.org](https://www.rfc-editor.org/rfc/rfc9207.html?utm_source=openai))
4. Build a migration policy, not an accidental downgrade path
Set an explicit compatibility policy, then verify the behavior of the SDK you actually ship. Protocol compatibility and SDK defaults differ. Do not write “supports latest MCP” without naming both the dated protocol revisions and the server transport mode.
| SDK evidence (version-specific) | What it means for an implementer |
|---|---|
| TypeScript SDK v2: hand-constructed Client, Server, or McpServer remains on the 2025-era protocol unless 2026-07-28 is explicitly selected through documented v2 opt-ins. | Audit constructors and transport setup; upgrading packages alone may not upgrade wire behavior. ([github.com](https://github.com/modelcontextprotocol/typescript-sdk/blob/main/docs/migration/support-2026-07-28.md?utm_source=openai)) |
| Python SDK v2: a client probes server/discover and falls back to legacy initialize; its HTTP/stdio server documentation says it can serve both revisions without a separate deployment configuration. | Test the fallback rather than assuming every host supports modern discovery. ([github.com](https://github.com/modelcontextprotocol/python-sdk/blob/main/docs/whats-new.md?utm_source=openai)) |
| Go SDK v1.7.0: modern HTTP requires StreamableHTTPOptions.Stateless = true; it negotiates the highest mutually supported revision and discovery falls back to initialize if needed. | Set stateless mode deliberately and narrow supported versions when retiring an era. ([github.com](https://github.com/modelcontextprotocol/go-sdk/releases?utm_source=openai)) |
| C# SDK: HTTP server transport defaults to stateless; clients probe/fallback by default, while pinning ProtocolVersion prevents silent downgrade. Stateful mode refuses 2026-07-28 requests. | Use a pinned modern-only test lane; do not mistake a successful legacy fallback for successful modern support. ([github.com](https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/concepts/stateless/stateless.md?utm_source=openai)) |
Atlas policy: serve 2026-07-28 as the preferred production path; support 2025-11-25 only for identified legacy hosts until a published retirement date; log negotiated revision and fallback reason; pin 2026-07-28 in conformance and security tests; reject deprecated-feature dependencies in new server capabilities. If an old host needs a session-dependent behavior, isolate it as a legacy adapter rather than weakening the modern endpoint’s authorization model.
5. Validate, recover, monitor, and hand off
Operationalize correctness. For the read tool, a retry after a network interruption is generally safe if it is side-effect free. For refresh, retries without duplicate-action controls are unsafe. Require a caller-provided idempotency key scoped to tenant, vendor, and operation; persist the initial accepted job result; return that result for duplicates; and make the external provider call idempotent where possible. A timeout means unknown outcome, not failure: query the job handle and reconcile the provider result before allowing another chargeable attempt.
Publish these observability fields: request/correlation ID, authenticated subject and tenant, negotiated MCP revision, client/host identity as telemetry rather than authorization proof, tool name, authorization decision, approval reference, idempotency disposition, external job handle, outcome, and safe error category. Never put bearer tokens, raw secrets, or unredacted sensitive vendor records in protocol logs. Replace removed protocol ping with transport/platform health checks and an authorized, non-mutating readiness operation if the product truly needs one.
Your test matrix must include: modern discovery and normal call; legacy initialize fallback; client pinned to 2026-07-28 against a legacy-only server; schema rejection; missing scope; wrong tenant; invalid/mismatched issuer; expired approval; duplicate refresh; provider timeout with subsequent reconciliation; malicious text embedded in vendor evidence; and load-balanced requests carrying an explicit job handle rather than server-local session state. Run the official conformance suite where your SDK/release process supports it, but retain integration tests for your authorization and side-effect rules—conformance cannot prove your business policy. The TypeScript SDK reports conformance coverage for both 2025-11-25 and 2026-07-28 in its project workflow, illustrating why dated-revision test lanes belong in maintenance planning. ([github.com](https://github.com/modelcontextprotocol/typescript-sdk/blob/main/ROADMAP.md?utm_source=openai))
Applied Practice: Atlas Procurement Boundary and Compatibility Review
Scenario: Fictional scenario: Atlas Procurement is building a supplier-risk capability. Its web application currently calls an internal REST endpoint directly. Product wants the same capability available in its internal analyst host, a partner-operated procurement host, and a future command-line automation client. The server can read vendor profiles and generate a risk summary; it can also request an external vendor-data refresh that costs money and changes the audit record. You must decide which boundary to use, classify legacy feature requests, and publish a dual-era compatibility policy without granting model text direct authority to trigger refreshes.
Create a one-page Atlas integration handoff package using synthetic data only. First, classify these six scenarios as MCP, direct API, or “MCP only with additional controls,” and give a two-sentence rationale for each: (1) the Atlas web UI calling its own billing calculation service; (2) three compatible analyst hosts needing vendor risk summaries; (3) a partner host requesting a chargeable vendor refresh; (4) a single cron worker reading a private database; (5) an independently owned document-evidence server used by several teams; (6) a host that cannot propagate a reliable user or workload identity for restricted records. Second, classify Roots, Sampling, protocol Logging, DCR, and ping as Active/Deprecated/Removed for a modern design response. Third, write a compatibility policy containing supported revisions, preferred revision, fallback criteria, legacy retirement trigger, and a SDK/transport configuration assumption you will verify. Finally, provide the two Atlas tool contracts, an authorization matrix, an idempotency rule, and a 10-case test matrix. Add the finished package to your MCP Systems Build Portfolio as “Boundary & Compatibility Review v1”; it becomes the architecture evidence you will refine in later Decision Labs.
Self-review checklist
- I classified all six scenarios based on ownership, host reuse, contract stability, and trust—not on whether an AI model appears in the workflow.
- I separated model-proposed intent from host authorization and deterministic server-side enforcement.
- I marked Roots, Sampling, and protocol Logging as Deprecated; I did not select them for a greenfield dependency.
- I documented a 2026-07-28 path and a bounded initialize-era fallback path.
- I specified idempotency/duplicate-action controls for the refresh side effect and an approval rule for consequential actions.
Module capstone: apply the module in the AI Agentic School Decision Lab below. Mastery unlocks the LearnDash completion control for this topic.
AI Agentic School Decision Lab
Please sign in to submit your module decision and receive feedback.
Key takeaways
- Use MCP when an independently owned capability should be reused across multiple compatible hosts through a stable, discoverable contract—not merely because an LLM is involved.
- As of September 10, 2026, the current stable dated MCP specification is 2026-07-28. The official repository lists no newer stable dated release; its 2026-07-28 RC is historical pre-release material, while the official release announcement identifies 2026-07-28 as GA.
- Treat 2026-07-28 as a distinct protocol era: stateless request handling, per-request metadata, optional server/discover, formal extensions, and MRTR replace initialize/session-based assumptions for modern traffic.
- Roots, Sampling, and protocol Logging are Deprecated—not foundations for new designs. Dynamic Client Registration is superseded by Client ID Metadata Documents, although compatibility support may remain. ping is removed in the 2026-07-28 revision.
- Version support is an operational policy: define your minimum accepted revision, legacy end-of-life date, fallback behavior, and tests—not just an SDK dependency range.
Useful terms
- Dated protocol revision
- An MCP wire-specification version identified by a date, such as 2026-07-28; compatibility must be evaluated against the named revision, not the word “latest.”
- MRTR
- Multi Round-Trip Requests: the modern mechanism used for interactions that require further exchanges, without relying on permanently open bidirectional session assumptions.
- Stateless protocol core
- The 2026-07-28 model in which each request carries necessary protocol/client metadata and protocol-level sessions are removed; application state may still exist through explicit server-managed handles.
- Feature lifecycle
- The formal status of a specification feature: Active, Deprecated, or Removed. Deprecated features have a migration obligation; Removed features cannot be a dependency for that revision.
Research & review note
This lesson is built from source-traceable research and reviewed before publication. AI Agentic School uses AI as a research and practice tool, not as a substitute for evidence or editorial judgment.
Sources & further reading
- modelcontextprotocol/blog/content/posts/2026-07-28-spec-ga/index.md at main · modelcontextprotocol/modelcontextprotocol · GitHub
- modelcontextprotocol/docs/specification/2026-07-28/changelog.mdx at main · modelcontextprotocol/modelcontextprotocol · GitHub
- RFC 9207: OAuth 2.0 Authorization Server Issuer Identification
- typescript-sdk/docs/migration/support-2026-07-28.md at main · modelcontextprotocol/typescript-sdk · GitHub
- python-sdk/docs/whats-new.md at main · modelcontextprotocol/python-sdk · GitHub
- Releases · modelcontextprotocol/go-sdk · GitHub
- csharp-sdk/docs/concepts/stateless/stateless.md at main · modelcontextprotocol/csharp-sdk · GitHub
- typescript-sdk/ROADMAP.md at main · modelcontextprotocol/typescript-sdk · GitHub