Guide

Can your gateway handle long-running MCP tools?

For long-running MCP work, confirm that the client, server, transport, and every intermediary support the same Tasks extension lifecycle. The `+'`2026-07-28`'+` MCP specification moved Tasks out of the experimental core into the `+'`io.modelcontextprotocol/tasks`'+'` extension. A gateway that only forwards ordinary `+'`tools/call`'+'` requests may not support task handles, polling, update notifications, or cancellation.

What changed in the current MCP specification

In the earlier experimental design, Tasks appeared in the protocol core. In the `+'`2026-07-28`'+` revision, the server may respond to an eligible tool call with a task handle; clients then use the extension’s task operations, including `+'`tasks/get`'+'` and `+'`tasks/update`'+'`. Task creation is server-directed. The previous `+'`tasks/list`'+'` method was removed because it could not be safely scoped without sessions. Consult the current specification and SDK version for the exact extension contract.

What an intermediary must preserve

  • Extension negotiation and support metadata.
  • Task identifiers without leaking them across tenants.
  • Polling, progress updates, cancellation, and terminal error states.
  • Caller identity, resource-specific authorization, and correlation IDs across requests.
  • Timeout and retry behavior that does not create duplicate side effects.
  • Task lifetime, storage, and deletion semantics.

Do not infer Tasks support from “MCP compatible,” from support for `+'`tools/call`'+'`, or from the gateway’s ability to stream a normal response. Those are related but distinct behaviors.

Check product scope carefully

As reviewed on 30 October 2026, Google Cloud API Gateway’s Public Preview documentation says it supports the basic MCP lifecycle and `+'`tools/list`'+'`/`+'`tools/call`'+'`, but does not support streaming or long-running tool calls. That is a concrete example of why protocol support must be tested feature by feature. It is not a claim about every Google product or every gateway.

A conformance test for long-running tools

  1. Use a harmless tool that takes longer than the gateway’s ordinary request timeout.
  2. Verify the server can return a task handle and the gateway does not convert it into a generic timeout.
  3. Poll as the same principal; verify another tenant cannot access the task ID.
  4. Test progress, completion, failure, cancellation, and a client disconnect.
  5. Retry a poll safely and retry task creation only when the server’s idempotency behavior is understood.
  6. Inspect logs and confirm task state is not retained longer than intended.

If your workload is synchronous and short-lived, plain tool calls may be simpler. Use the Tasks extension when the work genuinely needs asynchronous lifecycle control, and treat extension support as an explicit interoperability requirement. For adjacent failure and retry design, see how gateway failover actually works.

Common questions

Are MCP Tasks still experimental?

The `2026-07-28` MCP specification moved Tasks into the `io.modelcontextprotocol/tasks` extension. Implementations must support the extension explicitly; do not assume all clients and gateways do.

Does MCP tool support imply support for long-running tasks?

No. A gateway may support synchronous `tools/call` while lacking task handles, polling, update, or cancellation behavior.

Was `tasks/list` retained in the new lifecycle?

The MCP maintainers’ specification announcement says `tasks/list` was removed because it could not be safely scoped without sessions. Check the current extension specification for exact method behavior.

Sources and editorial review dates are recorded with this guide. Catalogue-backed blocks use the dated catalogue snapshot. See our methodology.