How AgentCore Gateway helps the MCP 2026-07-28 spec

At this time, the Mannequin Context Protocol (MCP) printed its 2026-07-28 specification, the most important and most vital revision of the protocol since its launch. With this launch MCP turns into a stateless protocol that scales on peculiar HTTP infrastructure. Alongside the transport adjustments, this new model introduces a ruled extensions system, strengthens authorization by aligning extra carefully with enterprise practices for OAuth 2.0 and OpenID Join, and establishes lifecycle ensures that restrict future breakage.

You can begin utilizing the most recent protocol in your AgentCore Gateway, a functionality of Amazon Bedrock AgentCore, right now by calling UpdateGateway with the record of variations you need your gateway to assist. Present purchasers preserve working precisely as earlier than, and there’s no per-target step. On this put up, we stroll by means of what modified within the protocol and why, what it means on your brokers and instruments, and methods to allow the brand new model in your gateways.

Already accustomed to the spec adjustments? Leap straight to Updating your AgentCore Gateway.

What adjustments with the brand new spec and why it issues

This launch comprises backward-incompatible adjustments to the MCP protocol. The transition to statelessness is a foundational change that protocol maintainers imagine is important to deal with scaling challenges with enterprise deployments. The introduction of breaking adjustments with new variations, nevertheless, is just not anticipated to be the norm. To assist facilitate backward-compatible updates in future revisions, maintainers have launched new governance enhancements to the protocol specification (a function lifecycle coverage, an extensions framework, and a conformance-suite requirement). These enhancements are designed to assist protocol evolution with out breaking core capabilities.

Upgrading can also be opt-in, and nothing adjustments till each you and your purchasers act. AgentCore Gateway advertises the protocol variations it speaks by means of a single configuration area. Purchasers choose a model on each request. Including 2026-07-28 to a gateway that additionally advertises 2025-11-25 doesn’t change something for purchasers that request the older model. Solely a consumer that requests 2026-07-28 will get the brand new conduct. Nothing breaks on July 28.

1. MCP is now stateless

In prior variations of the protocol, each Streamable HTTP interplay with an MCP server started with an initialize/initialized handshake, through which the consumer and server exchanged protocol variations and capabilities. The server then issued an Mcp-Session-Id header that each subsequent request was required to hold:

POST /mcp HTTP/1.1
Mcp-Session-Id: 1868a90c-3a3f-4f5b
Content material-Kind: utility/json
Settle for: utility/json

{"jsonrpc":"2.0","id":2,"technique":"instruments/name",
"params":{"identify":"search","arguments":{"q":"otters"}}}

That session pinned the consumer to the server that issued it. Due to this fact, to scale an MCP server horizontally, operators wanted sticky classes on the load balancer, a shared session retailer behind the fleet, or each.

By eradicating classes, distant MCP servers successfully grow to be customary HTTPS endpoints, which scale cleanly with enterprise workloads. Because the protocol turns into stateless, the handshake and the protocol-level session are each not wanted (SEP-2575 and SEP-2567 take away these necessities from the brand new protocol model). With 2026-07-28, each request now carries protocol model, consumer information, and consumer capabilities inside its _meta parameter, eliminating the necessity for a one-time initialization handshake. Purchasers that have to study what a server helps can name the brand new server/uncover technique at any level. The web impact is {that a} single software name is totally self-contained. It requires no prior session context and might be routed to any server occasion. Eradicating the protocol session doesn’t preclude assist for stateful functions. When servers want continuity throughout calls, you may comply with established patterns for HTTP requests by passing an express ID as a software parameter, which ought to come from one among your individual instruments.

POST /mcp HTTP/1.1
MCP-Protocol-Model: 2026-07-28
Mcp-Technique: instruments/name
Mcp-Title: create_basket
Content material-Kind: utility/json
Settle for: utility/json,textual content/event-stream

{"jsonrpc":"2.0","id":1,"technique":"instruments/name",
"params":{"identify":"create_basket","arguments":{},
"_meta":{"io.modelcontextprotocol/clientInfo":{"identify":"my-app","model":"1.0"}}}}

Response:

{"jsonrpc":"2.0","id":1,
"consequence":{"resultType":"full","content material":[{"type":"text","text":"Created basket bsk_a1b2c3"}],"structuredContent":{"basket_id":"bsk_a1b2c3"},"isError": false}}

You possibly can then use the agent’s personal capabilities to string this state deal with by means of subsequent requests:

POST /mcp HTTP/1.1
MCP-Protocol-Model: 2026-07-28
Mcp-Technique: instruments/name
Mcp-Title: add_item
Content material-Kind: utility/json
Settle for: utility/json,textual content/event-stream

{"jsonrpc":"2.0","id":1,"technique":"instruments/name",
"params":{"identify":"add_item","arguments":{"basket_id": "bsk_a1b2c3", "sku": "sneakers"},
"_meta":{"io.modelcontextprotocol/clientInfo":{"identify":"my-app","model":"1.0"}}}}

AgentCore Gateway has all the time shielded brokers from a lot of MCP’s session mechanics. It aggregates your AWS Lambda capabilities, APIs, and MCP servers behind a single MCP endpoint and manages the protocol dialog with every goal in your behalf. With 2026-07-28, that will get less complicated on either side: an agent’s first software name is one self-contained request fairly than a handshake adopted by a name. Every request carries an Mcp-Protocol-Model header. The gateway serves the request in that model when the model seems in supportedVersions, or rejects it with HTTP 400 (code -32022) and a listing of supported variations when it doesn’t. Requests that omit the header default to 2025-03-26.

2. Routing, caching, and tracing with out parsing the physique

In prior variations of the protocol, the operation a request carried out was opaque to something sitting between consumer and server. Load balancers, API gateways, and fee limiters all needed to parse the JSON-RPC physique to find out what technique was being known as. Detecting adjustments to a server’s software catalog meant holding a long-lived SSE stream open and ready for a push notification. MCP visitors, in brief, didn’t play properly with customary HTTP infrastructure.

2026-07-28 closes that hole in 3 ways. First, each Streamable HTTP request now surfaces its intent in customary headers: Mcp-Technique and Mcp-Title (SEP-2243) journey exterior the physique, giving intermediaries sufficient info to route, throttle, and meter on the HTTP layer alone. A server that receives a request the place the declared headers contradict the physique rejects it outright. Second, responses to record and resource-read operations now embrace express freshness metadata, ttlMs and cacheScope, borrowed from the semantics of HTTP Cache-Management (SEP-2549). Purchasers can cache a instruments/record response for a identified length and scope with out sustaining a persistent connection solely to look at for invalidations. Third, the spec now reserves the W3C Hint Context keys (traceparent, tracestate, baggage) inside _meta (SEP-414), formalizing what a number of SDKs had already adopted in observe. A distributed hint originating in your utility can now propagate by means of the complete name chain, from agent to MCP consumer to gateway to downstream service, and render as a unified span tree in any OpenTelemetry-compatible collector.

On the 2026-07-28 path, AgentCore Gateway surfaces these primitives immediately. Each software consequence out of your gateway carries the brand new structured consequence envelope, and cacheable outcomes embrace TTL and scope hints for conformant consumer SDKs. The gateway additionally enforces the custom-header binding: when a software’s enter schema marks a area as header-bound, the gateway rejects any request whose header is absent or contradicts the physique (HTTP 400, code -32020).

3. Server-to-client interactions with out persistent connections

A stateless protocol nonetheless wants a means for a server to speak again to the consumer mid-call. MCP has three such interactions: elicitation, the place the server asks the tip consumer for enter (“this software is about to delete three recordsdata. Affirm?”), roots, the place the server asks for obtainable directories and recordsdata within the filesystem, and sampling, the place the server asks the consumer’s mannequin to generate a response. In earlier variations, delivering these requests meant the server held an SSE stream open again to the consumer.

With the most recent protocol model, server-initiated requests are actually solely permitted whereas the server is actively processing a consumer request (SEP-2260). Each immediate a consumer sees traces again to one thing they or their agent began. Multi Spherical-Journey Requests (SEP-2322) substitute the earlier long-lived stream. Right here, the server embeds questions in an InputRequiredResult and externalizes state by means of an opaque requestState token fairly than pushing a query over SSE. Solely instruments that declare elicitation or sampling inputs set off the multi-round-trip trade, and solely when the consumer advertises assist for it.

{
  "resultType": "input_required",
  "inputRequests": {
    "verify": {
      "technique": "elicitation/create",
      "params": {
        "mode": "type",
        "message": "Delete 3 recordsdata?",
        "requestedSchema": {
          "sort": "object",
          "properties": {
            "verify": {
              "sort": "boolean"
            },
            "required": ["confirm"]
          }
        }
      }
    },
    "requestState": "eyJzdGVwIjoxLCJmaWxlcyI6WyJhIiwiYiIsImMiXX0="
  }
}

Purchasers acquire the consumer’s solutions and re-issue the unique name with the responses and the requestState. The whole lot the server wants is within the payload, so any server occasion can choose up the retry.

Individually, progress notifications and log supply are actually request-scoped. The gateway relays progress updates solely when the consumer provides a progress token on the originating request, and delivers log messages solely when the consumer units io.modelcontextprotocol/logLevel in per-request metadata.

4. Decoupling extensions from the core spec

Till now, MCP extensions have been a casual idea with no governance behind them. SEP-2133 introduces one. Every extension carries a reverse-DNS ID, is negotiated by means of an extensions map in consumer and server capabilities, lives in a devoted repository below delegated maintainers, and follows its personal launch cadence impartial of the core spec. A brand new Extensions Observe inside the SEP course of defines how an extension graduates from experimental to official standing, which adjustments how the protocol grows. Quite than each new thought competing for house within the core specification and forcing a breaking model bump, capabilities can now mature as opt-in extensions on their very own timelines. Purchasers and servers that don’t negotiate a given extension are unaffected.

5. Authorization hardening

Six SEPs convey MCP’s authorization specification into nearer alignment with manufacturing OAuth 2.0 and OpenID Join deployments. Your gateway’s inbound authorization, whether or not IAM (SigV4) or OAuth/JWT, is unchanged by the protocol model. So are your outbound credential suppliers. Upgrading the protocol model doesn’t require altering credentials or authorizer configuration.

6. Error dealing with and deprecations

On earlier protocol variations, almost every part got here again as HTTP 200 with an error tucked contained in the JSON-RPC physique, together with transport-level failures. On 2026-07-28, the transport and utility layers are cleanly separated. Transport failures return actual HTTP standing codes. Utility-level outcomes keep within the physique:

These adjustments solely matter for code that inspects error responses. They let your HTTP-level monitoring, alarming, and retry logic distinguish routing issues from application-level points with out parsing the physique. The spec additionally reassigns the “useful resource not discovered” error code from the MCP-specific -32002 to JSON-RPC’s customary -32602 Invalid Params (SEP-2164). In case your consumer matches on -32002 wherever, audit these code paths. Moreover, on the 2026-07-28 path: logging/setLevel is retired, and a consumer that calls it’s rejected. To decide into log supply, you may set the per-request metadata area io.modelcontextprotocol/logLevel as a substitute.

Three core options are deprecated below the protocol’s new function lifecycle coverage (SEP-2577): Roots (changed by software parameters, useful resource URIs, or server configuration), Sampling (changed by direct integration with LLM supplier APIs), and Logging (changed by stderr for stdio transports and OpenTelemetry for structured observability). These deprecations are advisory. The strategies, varieties, and functionality flags stay practical on this launch and in any specification model printed inside twelve months of it. Nonetheless, we extremely suggest that new implementations not take a dependency on them.

7. Schema assist

Device inputSchema and outputSchema now assist the complete JSON Schema 2020-12 vocabulary (SEP-2106). Enter schemas retain the sort: "object" root requirement however acquire composition key phrases (oneOf, anyOf, allOf), conditionals, and inside references ($ref, $defs). Output schemas don’t have any root-type restriction, and structuredContent could also be any legitimate JSON worth. Implementations should not comply with exterior $ref URIs routinely and will implement depth and cut-off dates throughout validation.

Deciding when you’re able to replace

Work by means of three questions earlier than you allow the brand new model:

1. Are your purchasers prepared? Your brokers attain Gateway by means of MCP consumer SDKs. Verify that the SDKs your agent frameworks and host functions use have shipped 2026-07-28 assist. Tier 1 SDKs have been anticipated to ship assist through the ten-week launch candidate window, so most mainstream stacks are prepared right now. See the MCP SDK documentation for the present tier record. Take a look at purchasers that assist 2026-07-28 earlier than you promote it on a manufacturing gateway.
2. Does something you run depend upon eliminated or modified conduct? Audit for: protocol classes used to hold utility state, logging/setLevel, consumer code matching the literal -32002 error code, and any dependence on Roots, Sampling, or Logging. In case your instruments use elicitation or sampling, notice that the gateway carries these by means of a brand new per-request mechanism on 2026-07-28 fairly than a persistent session. Affirm your purchasers declare the matching functionality. A consumer that omits it’s rejected with code -32021.
3. Do you management either side? You don’t have to. Model choice occurs per request, so a dual-version gateway serves previous and new purchasers concurrently. You possibly can improve purchasers and the gateway on impartial schedules, in both order.

For the complete particulars, see the MCP 2026-07-28 specification the changelog in opposition to 2025-11-25, and the MCP weblog’s launch candidate announcement

Updating your AgentCore Gateway

For AgentCore Gateway prospects, adopting 2026-07-28 is a configuration change. Your AgentCore Gateway can assist a number of protocol variations concurrently. You possibly can add 2026-07-28 to your gateway’s record of supportedVersions with a single UpdateGateway name. There’s no have to re-create the gateway or make adjustments to particular person gateway goal configurations. The MCP model is a property of the gateway, not of its targets, and updates to that property are carried out in place. Device definitions, goal configuration, and inbound authentication (IAM and OAuth) are all unchanged by the model change.

UpdateGateway replaces supportedVersions with the set you ship. It doesn’t append. Learn the present configuration first, then ship the entire record you need the gateway to promote:

# 1. Learn the present configuration.
aws bedrock-agentcore-control get-gateway 
    --gateway-identifier 

# 2. Promote 2026-07-28 alongside the prevailing model.
aws bedrock-agentcore-control update-gateway 
    --name  
    --role-arn  
    --protocol-type MCP 
    --authorizer-type  
    --gateway-identifier  
    --protocol-configuration '{
  "mcp": {
    "supportedVersions": ["2025-11-25", "2026-07-28"]
  }
}'

AgentCore Gateway works with any of the next protocol variations: 2025-03-26, 2025-06-18, 2025-11-25, and 2026-07-28.

Affirm the brand new model is stay by calling your gateway with the brand new headers:

curl -s https:///mcp 
    -H "Authorization: Bearer $TOKEN" 
    -H "Content material-Kind: utility/json" 
    -H "Settle for: utility/json,textual content/event-stream" 
    -H "MCP-Protocol-Model: 2026-07-28" 
    -H "Mcp-Technique: instruments/record" 
    -d '{"jsonrpc":"2.0","id":1,"technique":"instruments/record","params":{}}'

A profitable response confirms the gateway served the request at 2026-07-28. A rejection with code -32022 means the model isn’t within the gateway’s supportedVersions but, and the response physique lists what the gateway at present advertises.

supportedVersions is the entire set the gateway advertises, so rolling again is identical operation in reverse. That’s, ship the record with out 2026-07-28. Requests specifying the eliminated model are rejected with a response physique itemizing the variations the gateway nonetheless helps. Be certain that purchasers you’ve already migrated can fall again earlier than you take away the model they’re requesting.

How model choice works

Purchasers choose a model on every request, not by means of a one-time handshake. Every MCP request declares its model within the MCP-Protocol-Model header, and the gateway honors it when it’s in supportedVersions:

• A request naming a model the gateway advertises is served in that model. On a dual-version gateway (for instance, 2026-07-28 and 2025-11-25), a 2026-07-28 request will get the brand new conduct and a 2025-11-25 request will get the sooner conduct.
• A request naming a model the gateway does not promote is rejected with HTTP 400 and code -32022. The response physique lists the variations the gateway helps.
• A request that omits the header will get the default model, 2025-03-26. If that default isn’t within the gateway’s supportedVersions, the request is rejected.

Your present purchasers proceed to work so long as they request protocol variations listed within the gateway’s supportedVersions. That provides you a clear, three-stage rollout: add 2026-07-28 alongside your present variations, migrate purchasers at your individual tempo, and solely in any case purchasers request the brand new model, trim the record down.

In case your gateway fronts an MCP server goal that upgrades to 2026-07-28 earlier than your purchasers do, it interprets between variations, so a 2025-* consumer can name peculiar instruments on a 2026-07-28 goal and obtain ends in the format it expects, with out upgrading. Nonetheless, this translation doesn’t at present assist elicitations and sampling calls from servers to purchasers. If a 2025-* consumer calls a software on the 2026-* server that requires elicitation or sampling, it receives an error.

Conclusion

MCP 2026-07-28 is the protocol’s largest revision ever, and it’s designed to be the final revision that breaks compatibility. Statelessness offers MCP a basis that scales on commodity HTTP infrastructure whereas MCP Extensions give new capabilities room to evolve on their very own schedules.

With Amazon Bedrock AgentCore Gateway, including assist for the most recent protocol model is just one UpdateGateway name. To get began, see the AgentCore Gateway documentation, assessment the MCP 2026-07-28 specification and its changelog, and take a look at enabling the brand new model on a gateway right now. If in case you have suggestions on the specification itself, the maintainers welcome points within the MCP specification repository. For questions on AgentCore Gateway, attain out by means of AWS re:Put up or your normal AWS Assist channels.

Concerning the authors