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

At present, the Mannequin Context Protocol (MCP) revealed its 2026-07-28 specification, the biggest and most important revision of the protocol since its launch. With this launch MCP turns into a stateless protocol that scales on strange HTTP infrastructure. Alongside the transport modifications, 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 this moment by calling UpdateGateway with the listing of variations you need your gateway to assist. Present shoppers preserve working precisely as earlier than, and there’s no per-target step. On this put up, we stroll via what modified within the protocol and why, what it means in your brokers and instruments, and the way to allow the brand new model in your gateways.

Already conversant in the spec modifications? Bounce straight to Updating your AgentCore Gateway.

What modifications with the brand new spec and why it issues

This launch comprises backward-incompatible modifications to the MCP protocol. The transition to statelessness is a foundational change that protocol maintainers consider is important to handle scaling challenges with enterprise deployments. The introduction of breaking modifications with new variations, nevertheless, isn’t 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 characteristic 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 be opt-in, and nothing modifications till each you and your shoppers act. AgentCore Gateway advertises the protocol variations it speaks via a single configuration area. Shoppers choose a model on each request. Including 2026-07-28 to a gateway that additionally advertises 2025-11-25 doesn’t change something for shoppers that request the older model. Solely a shopper that requests 2026-07-28 will get the brand new habits. 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, wherein the shopper 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-Sort: software/json
Settle for: software/json

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

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

By eradicating periods, distant MCP servers successfully grow to be normal HTTPS endpoints, which scale cleanly with enterprise workloads. Because the protocol turns into stateless, the handshake and the protocol-level session are each now 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, shopper data, and shopper capabilities inside its _meta parameter, eliminating the necessity for a one-time initialization handshake. Shoppers that must study what a server helps can name the brand new server/uncover methodology at any level. The web impact is {that a} single software name is totally self-contained. It requires no prior session context and could be routed to any server occasion. Eradicating the protocol session doesn’t preclude assist for stateful purposes. When servers want continuity throughout calls, you’ll be able to comply with established patterns for HTTP requests by passing an express ID as a software parameter, which ought to come from one in every of your personal instruments.

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

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

Response:

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

You may then use the agent’s personal capabilities to string this state deal with via subsequent requests:

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

{"jsonrpc":"2.0","id":1,"methodology":"instruments/name",
"params":{"identify":"add_item","arguments":{"basket_id": "bsk_a1b2c3", "sku": "footwear"},
"_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 features, 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 easier on either side: an agent’s first software name is one self-contained request relatively 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 shopper and server. Load balancers, API gateways, and price limiters all needed to parse the JSON-RPC physique to find out what methodology was being referred to as. Detecting modifications to a server’s software catalog meant holding a long-lived SSE stream open and ready for a push notification. MCP site visitors, in brief, didn’t play nicely with normal HTTP infrastructure.

2026-07-28 closes that hole in 3 ways. First, each Streamable HTTP request now surfaces its intent in normal headers: Mcp-Technique and Mcp-Identify (SEP-2243) journey outdoors 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 listing and resource-read operations now embody express freshness metadata, ttlMs and cacheScope, borrowed from the semantics of HTTP Cache-Management (SEP-2549). Shoppers can cache a instruments/listing response for a identified period 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 software can now propagate via the total name chain, from agent to MCP shopper 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 straight. Each software end result out of your gateway carries the brand new structured end result envelope, and cacheable outcomes embody TTL and scope hints for conformant shopper 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 manner for a server to speak again to the shopper 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 information. Verify?”), roots, the place the server asks for accessible directories and information within the filesystem, and sampling, the place the server asks the shopper’s mannequin to generate a response. In earlier variations, delivering these requests meant the server held an SSE stream open again to the shopper.

With the most recent protocol model, server-initiated requests at the moment are solely permitted whereas the server is actively processing a shopper 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 via an opaque requestState token relatively than pushing a query over SSE. Solely instruments that declare elicitation or sampling inputs set off the multi-round-trip change, and solely when the shopper advertises assist for it.

{
  "resultType": "input_required",
  "inputRequests": {
    "affirm": {
      "methodology": "elicitation/create",
      "params": {
        "mode": "type",
        "message": "Delete 3 information?",
        "requestedSchema": {
          "kind": "object",
          "properties": {
            "affirm": {
              "kind": "boolean"
            },
            "required": ["confirm"]
          }
        }
      }
    },
    "requestState": "eyJzdGVwIjoxLCJmaWxlcyI6WyJhIiwiYiIsImMiXX0="
  }
}

Shoppers gather the consumer’s solutions and re-issue the unique name with the responses and the requestState. Every part the server wants is within the payload, so any server occasion can choose up the retry.

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

4. Decoupling extensions from the core spec

Till now, MCP extensions had been a casual idea with no governance behind them. SEP-2133 introduces one. Every extension carries a reverse-DNS ID, is negotiated via an extensions map in shopper 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 Monitor throughout the SEP course of defines how an extension graduates from experimental to official standing, which modifications how the protocol grows. Relatively 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. Shoppers and servers that don’t negotiate a given extension are unaffected.

5. Authorization hardening

Six SEPs deliver 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, practically the whole lot 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 software layers are cleanly separated. Transport failures return actual HTTP standing codes. Utility-level outcomes keep within the physique:

These modifications 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 normal -32602 Invalid Params (SEP-2164). In case your shopper matches on -32002 anyplace, audit these code paths. Moreover, on the 2026-07-28 path: logging/setLevel is retired, and a shopper that calls it’s rejected. To decide into log supply, you’ll be able to set the per-request metadata area io.modelcontextprotocol/logLevel as an alternative.

Three core options are deprecated below the protocol’s new characteristic 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, sorts, and functionality flags stay useful on this launch and in any specification model revealed inside twelve months of it. Nevertheless, we extremely advocate that new implementations not take a dependency on them.

7. Schema assist

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

Deciding when you’re able to replace

Work via three questions earlier than you allow the brand new model:

1. Are your shoppers prepared? Your brokers attain Gateway via MCP shopper SDKs. Examine that the SDKs your agent frameworks and host purposes use have shipped 2026-07-28 assist. Tier 1 SDKs had been anticipated to ship assist in the course of the ten-week launch candidate window, so most mainstream stacks are prepared right this moment. See the MCP SDK documentation for the present tier listing. Check shoppers that assist 2026-07-28 earlier than you promote it on a manufacturing gateway.
2. Does something you run rely upon eliminated or modified habits? Audit for: protocol periods used to hold software state, logging/setLevel, shopper 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 via a brand new per-request mechanism on 2026-07-28 relatively than a persistent session. Verify your shoppers declare the matching functionality. A shopper that omits it’s rejected with code -32021.
3. Do you management either side? You don’t must. Model choice occurs per request, so a dual-version gateway serves outdated and new shoppers concurrently. You may improve shoppers and the gateway on impartial schedules, in both order.

For the total particulars, see the MCP 2026-07-28 specification the changelog against 2025-11-25, and the MCP blog’s release candidate announcement

Updating your AgentCore Gateway

For AgentCore Gateway clients, adopting 2026-07-28 is a configuration change. Your AgentCore Gateway can assist a number of protocol variations concurrently. You may add 2026-07-28 to your gateway’s listing of supportedVersions with a single UpdateGateway name. There’s no must re-create the gateway or make modifications 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 whole listing you need the gateway to promote:

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

# 2. Promote 2026-07-28 alongside the present model.
aws bedrock-agentcore-control update-gateway 
    --name <gateway-name> 
    --role-arn <gateway-role-arn> 
    --protocol-type MCP 
    --authorizer-type <gateway-authorizer-type> 
    --gateway-identifier <gateway-id> 
    --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.

Verify the brand new model is dwell by calling your gateway with the brand new headers:

curl -s https://<your-gateway-endpoint>/mcp 
    -H "Authorization: Bearer $TOKEN" 
    -H "Content material-Sort: software/json" 
    -H "Settle for: software/json,textual content/event-stream" 
    -H "MCP-Protocol-Model: 2026-07-28" 
    -H "Mcp-Technique: instruments/listing" 
    -d '{"jsonrpc":"2.0","id":1,"methodology":"instruments/listing","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 whole set the gateway advertises, so rolling again is identical operation in reverse. That’s, ship the listing with out 2026-07-28. Requests specifying the eliminated model are rejected with a response physique itemizing the variations the gateway nonetheless helps. Ensure that shoppers you’ve already migrated can fall again earlier than you take away the model they’re requesting.

How model choice works

Shoppers choose a model on every request, not via 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 habits and a 2025-11-25 request will get the sooner habits.
• 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 shoppers 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 shoppers at your personal tempo, and solely in spite of everything shoppers request the brand new model, trim the listing down.

In case your gateway fronts an MCP server goal that upgrades to 2026-07-28 earlier than your shoppers do, it interprets between variations, so a 2025-* shopper can name strange instruments on a 2026-07-28 goal and obtain leads to the format it expects, with out upgrading. Nevertheless, this translation doesn’t at present assist elicitations and sampling calls from servers to shoppers. If a 2025-* shopper 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 greatest 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, evaluate the MCP 2026-07-28 specification and its changelog, and take a look at enabling the brand new model on a gateway right this moment. 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 via AWS re:Post or your ordinary AWS Assist channels.

In regards to the authors