# Model Context Protocol drafts a file upload and download extension for AI agents

> The MCP project released a draft extension that moves file transfers out of the model's context, though it is experimental and not yet stable.

- Status: official (From the company, authors or authority themselves, with a link to their own page.)
- Topic: Open Source
- Published: 2026-11-10T09:00:00+00:00
- Updated: 2026-11-11T11:09:10.351189+00:00
- Web page: https://ai-news.ikangai.com/story/model-context-protocol-drafts-a-file-upload-and-download-extension-for-ai-agents/
- Seen in: Model Context Protocol
- Change: capability (New capability)
- Applies to: io.modelcontextprotocol/files

## What changed

The MCP project published a draft experimental extension, io.modelcontextprotocol/files, that moves file transfers out of the model's context so that bytes and upload URLs no longer pass through the model.

The Model Context Protocol project has published a draft extension that moves file transfers out of the model's context. It lets an MCP tool upload a file to a storage service, or download one from it, without the bytes or the URLs passing through the model. The extension, identified as io.modelcontextprotocol/files, works with protocol revision 2026-07-28 and later. The post describes it as experimental.

The motivation is practical. Saving a PDF from a conversation to cloud storage, or pulling a CSV into a code sandbox, are common requests from developers adopting MCP. According to the post, doing them today requires bespoke tool conventions and transfer mechanisms for each one. The design rests on one observation: the agent needs to know things about a file, such as its name, type and size, but the model does not need to read every byte. The file should travel directly to its destination.

The mechanism starts with the tool's input schema. A server marks a file argument with x-mcp-file, the same pattern the project already uses for x-mcp-header. That tells the client to fill in the argument itself, so the model never has to produce the file. Small files can be sent inline as base64 in a data field, provided the total inline data in one request stays within the maxInlineBytes value the server advertises. The example server advertises 1048576 bytes, or 1 MiB. Each file is also limited by maxSize, which the example PDF tool sets to 157286400 bytes, or 150 MiB. Clients that don't support the extension ignore the keyword and treat the argument as an ordinary object. If a client doesn't declare support, the server should either omit the tool or offer an alternative, such as accepting a URL to a file that is already uploaded.

For a larger file, the first tool call carries only metadata, after the host has obtained the user's approval or applied operator policy when no user is present. The example sends a 41204133-byte PDF, which the post rounds to 40 MB. The server can check permissions and storage quota before any bytes move. A read-only destination folder is caught before the upload begins, not after a 40 MB transfer. If the checks pass, the server answers with a new result type, upload_required. It lists the upload URL, headers, a credentials setting, an advisory expiry time and a requestState value. The requestState is opaque to the client. The server packages what it needs to finish the job and protects the state against tampering, and the client returns it unchanged. Because the state carries its own context rather than relying on a session, any server instance that can verify it and reach the uploaded file can finish the job. For tools that must not run twice, the server marks the requestState as used in a record shared by all instances, and a second attempt with the same value is rejected.

The client then sends the bytes over HTTPS, using PUT by default or POST for storage services that require a multipart form. When the upload returns a 2xx status, the client repeats the tool call with the same arguments and the returned requestState. The server verifies the state, confirms with the storage service that the file arrived, checks its size and type, and only then runs the tool. If the upload fails, the client does not send the retry and the tool does not run. According to the post, the model is involved in none of these steps. Neither the bytes nor the upload URL enter its context.

Downloads reverse the flow, with one difference. The tool returns download details in the _meta field of its completed result, so the client does not need a retry. The client then fetches the file with an HTTPS GET. The post explains the split: an upload needs a signal telling the client to transfer and retry before the tool can run, while a download is part of a finished result. The download format is still open. The post says the team is using _meta for now and wants feedback on how that works in practice. After download, the client checks the byte count against the declared size. If the server supplied a SHA-256 digest, the client compares the hash, and a mismatch means the file must be discarded. The post says a matching digest shows only that the bytes match the supplied hash, not that the file is safe, so clients must still treat downloaded files as untrusted.

The credentials setting addresses a specific risk: a file may go to a storage service rather than to the MCP server, and sending the client's MCP token to an unrelated host would expose it. Each target therefore declares either omit or include. With omit, the client attaches none of its MCP token, cookies or other credentials, and the target relies on its own authorization, such as a signature in a pre-signed URL. With include, the client attaches its MCP credential only to a path under its MCP address or to a URL on the server's own origin, which suits gateways. The client must also refuse redirects and reject targets that supply their own Authorization header. The post acknowledges that these rules control where the credential goes, but not where the file goes. With omit, a malicious server could direct an upload to a public endpoint it controls, and the user's approval was given before the host knew the destination.

The extension is optional, so clients and servers with no interest in it need do nothing. The post says there is no reference implementation yet and expects the inner workings to change once the experiment is connected to third-party file services, such as cloud storage and database import and export. The project expects to finalize the extension and make it stable before the end of the year. The repository's README adds that it is not part of the MCP specification, has not been proposed as a SEP, and should be expected to see breaking changes while the working group iterates.

## Original source

- [Exploring File Uploads and Downloads in MCP | Model Context Protocol Blog](https://blog.modelcontextprotocol.io/posts/exploring-file-uploads-and-downloads-in-mcp/)
- [experimental-ext-file-uploads/specification/draft/file-uploads.md at main · modelcontextprotocol/experimental-ext-file-uploads · GitHub](https://github.com/modelcontextprotocol/experimental-ext-file-uploads/blob/main/specification/draft/file-uploads.md)
- [GitHub - modelcontextprotocol/experimental-ext-file-uploads: Experimental MCP extension for uploading files to tools over MCP. Maintained by the File Uploads Wo](https://github.com/modelcontextprotocol/experimental-ext-file-uploads)

---

AI wrote this summary from the sources listed, and nobody reviewed it individually before publication. Check the original source before you rely on it.

Cite as: IKANGAI AI News, "Model Context Protocol drafts a file upload and download extension for AI agents", 2026-11-10, https://ai-news.ikangai.com/story/model-context-protocol-drafts-a-file-upload-and-download-extension-for-ai-agents/
