Notion and Block push MCP tools toward workflows as the protocol drops its session

The session leaves the protocol

Under MCP 2025-11-25, a tool call over Streamable HTTP starts with an initialize request. The server answers with an Mcp-Session-Id that every later request must carry, and that header pins the client to the instance that issued it ^[21]. Under 2026-07-28 the same call is one self-contained request that any server instance can handle ^[22]. In the project's own examples, that is one request fewer for a first tool call ^[36].

The handshake is removed (SEP-2575). Protocol version, client info and client capabilities now ride in _meta on every request, and a new server/discover method lets a client fetch server capabilities when it wants them up front ^[23]. The Mcp-Session-Id header and the protocol-level session go too (SEP-2567) ^[24]. Six SEPs work together to get there ^[25].

The payoff is in operations. A remote server that needed sticky sessions, a shared session store and deep packet inspection at the gateway can now run behind a plain round-robin load balancer. It can route on an Mcp-Method header, and clients can cache tools/list responses for as long as the server's ttlMs permits ^[26]. That removes three pieces of infrastructure from the requirements ^[37]. In its release-candidate post, the project called 2026-07-28 the largest revision of the protocol since launch and said it contains breaking changes ^[20].

The final specification shipped on July 28, 2026, with SDKs released the same day ^[31]. Both removals are in the final text, which carries method and tool names in the Mcp-Method and Mcp-Name headers and puts ttlMs and cacheScope on list responses ^[33]. The TypeScript, Python, Go and C# SDKs are updated to match, and the Rust SDK supports the new spec in beta ^[32]. Roots, Sampling and Logging are deprecated under SEP-2577, and the project said they will keep working for at least twelve months ^[34]. The legacy HTTP+SSE transport is deprecated as well, with what the post calls "a year-long offramp" ^[35].

State moves into the tool contract

The revision does not forbid state. The MCP team wrote that removing the protocol-level session "does not mean your application has to be stateless" ^[27]. A server that needs state across calls mints a handle from a tool, such as a basket_id or a browser_id, and the model passes it back as an ordinary argument on later calls ^[27]. The team wrote that it has found the pattern to be "more than just a workable substitute for session state" ^[28], and that the pattern "makes the state visible to the model" ^[29].

So the cost lands on servers that used the session as a store. In our view, the migration job for a stateful server is to write the handle into the tool contract. Block's playbook says tool names, descriptions and parameters are treated as prompts for the LLM ^[15]. A handle is a parameter, so the model reads its name and description the same way.

Block also prefers actionable error messages that let the agent recover over vague instructions ^[19]. We'd expect that to apply to a stale handle. An error that names the tool which mints a new one gives the model a next step.

The revision also changes who can speak first. Server-initiated requests may now be issued only while the server is actively processing a client request (SEP-2260). Earlier spec versions recommended that; it is now required. The stated effect is that every elicitation traces back to something the user or their agent started ^[30]. A server that prompts a user on its own schedule is out of line with that rule.

What Notion took apart

Notion's first release was a downloadable server, shipped in early April, that could be installed in Cursor or Claude Desktop ^[1]. Setup meant creating a Notion API integration and either copying its API key into MCP headers or building a Docker image ^[2]. Behind it, the library parsed a formal description of the API's endpoints and converted each MCP tool call into an HTTP call to Notion's public API using the configured key. Each endpoint mapped 1:1 to a tool ^[3].

Notion wrote that early-adopter feedback gave two insights. The technical barrier was too high for widespread adoption. And "the 1:1 API mapping created suboptimal experiences for AI agents, like high-context token consumption from working with hierarchical block data in JSON" ^[4].

Those are two causes, and only one concerns tool shape. The hosted server answers the install problem: each user goes through a one-click OAuth flow to connect the same public integration ^[5], and Notion can ship improvements without users downloading updated packages ^[6]. The shape problem gets its own fix. Notion says the hosted integration exposes "a tailored suite of tools optimized for AI agents", not HTTP calls to the API, and can ship functionality slices with "LLM-friendly descriptions" that are reachable only through the MCP server ^[7].

Notion did not discard its schemas. It built a code-generation pipeline that converts its generated OpenAPI schemas to Zod and plumbs those into the hosted server's tools ^[8]. It also says it sees MCP and specification tools like OpenAPI as working together ^[9]. In our view the endpoint inventory still feeds the server, with a curated tool list on top of it.

What Block adds

Block has built more than 60 MCP servers, and its playbook reflects patterns across them ^[10]. The first best practice is headed "Design top-down from workflows, not bottom-up from API endpoints" ^[11]. The playbook says to start from the workflow that needs automating and work backwards "in as few steps as possible" ^[11]. It says raw endpoints such as GET /user or GET /file usually produce verbose, poorly scoped outputs ^[12].

Its example has two tools, get_user and upload_file. The get_user call returns a giant JSON blob when the caller needs only a username. Block's recommended version is one upload_file(path, owner) tool that gets the user, uploads the file with the owner and returns a success or error message ^[13].

Block ties shape to context budget. It notes that Claude 3.7 can process at most 200K input tokens, and says performance drops for large contexts even on models with larger windows ^[16]. For tools that may return a lot, it lists three responses: raise an error, reduce the output with a note that it was truncated, or paginate. Pagination trades fewer tool calls against the token budget ^[17]. In the Goose file reader, files over 400kB raise a tool execution error. Block says LLMs work around that with shell commands such as sed -n ^[18].

Only Notion's account describes replacing a server. Block's playbook is guidance drawn from its 60-plus servers ^[10]. The passages available do not include token counts from Notion, a rebuilt Block server, or any mention of the 2026-07-28 revision by either company.

Where tool shape and state meet

Both companies name the same cost. Notion points to high-context token consumption from hierarchical block data in JSON ^[4]. Block points to a giant JSON blob returned when only a username is needed ^[13].

In our view, tool shape and state are one decision. A workflow tool that does the lookup and the upload in one call needs no handle between those steps ^[13]. Where a chain stays, Block says to spell out the steps and dependencies in the tool's instructions and keep earlier outputs concise ^[14]. Under the new protocol, what links the steps is an argument the model passes ^[27]. Pagination is the plain case. Block says some outputs must be fetched page by page through tool calls ^[17], and we'd expect the page position to travel as an argument too.

How far Notion's result transfers depends on the API behind the server. Its problem was hierarchical block data returned as JSON ^[4]. A server whose endpoints already return small, flat answers has less to gain from remapping. Block hedges its own advice: it says it is "usually better to start top-down" from the workflow ^[11].