MCP se Torna Stateless: Por Que a Maior Atualização do Protocolo Corta Funcionalidades em Vez de Adicioná-las

O Model Context Protocol acabou de lançar sua maior revisão de todos os tempos — e a direção surpreendeu quase todo mundo. Em vez de adicionar funcionalidades, os mantenedores as removeram: o handshake de inicialização foi embora, a aderência de sessão foi abolida, e o protocolo retorna ao ponto de origem do HTTP stateless.

Alguns zombaram, chamando de regressão à idade da pedra; outros disseram que é o salto que leva o MCP do protótipo à produção. Por trás da discussão existe uma pergunta mais fundamental: em ambientes de produção, para quem um protocolo de agentes de IA deve ser otimizado?

Um Mega-Lançamento Subtrativo

Em 21 de maio de 2026, os mantenedores do MCP congelaram o release candidate da versão 2026-07-28 e publicaram a especificação final em 28 de julho. A redação oficial foi incomummente direta: a maior revisão desde o lançamento do protocolo. Seu núcleo, em uma frase: o MCP agora é stateless na camada de protocolo.

Três coisas aconteceram de uma vez:

• O handshake de inicialização foi removido (SEP-2575). Os clientes costumavam abrir com uma chamada initialize trocando a versão do protocolo e listas de capacidades com o servidor. Esses detalhes não são mais trocados uma vez por conexão — agora viajam no campo _meta de cada requisição.
• Sessões e o header Mcp-Session-Id foram removidos (SEP-2567). Os servidores costumavam emitir um ID de sessão que toda requisição subsequente precisava carregar, prendendo o cliente à instância que o emitiu. Agora qualquer requisição pode cair em qualquer instância.
• Um novo método server/discover foi adicionado: os clientes consultam as capacidades do servidor sob demanda, a qualquer momento, em vez de recebê-las uma única vez na configuração da conexão.

Antes: primeiro o handshake, depois estabelecer uma sessão, então trabalhar. Agora: cada requisição carrega todo o seu contexto, e quem a recebe pode servi-la. O que foi removido era justamente o que muitos consideravam as funcionalidades definidoras do MCP. Por que se amputar?

Por Que as Sessões Tinham que Ir

Entender a revisão exige voltar à suposição original de design do MCP. Sua forma mais antiga e conhecida era a de aplicativos desktop conversando com processos locais via entrada/saída padrão. Nesse mundo, conexões persistentes e handshakes eram praticamente gratuitos — é um único processo, e nenhuma requisição precisa se perguntar qual instância deveria atendê-la.

Mas, conforme o ecossistema amadureceu, cada vez mais servidores migraram para implantações remotas e escaladas horizontalmente — e ali, as sessões viraram um pecado original que carregava dois impostos pesados.

Imposto um: a complexidade de sistemas distribuídos. Assim que um servidor emite um Mcp-Session-Id, o cliente fica vinculado à instância emissora. Para escalar horizontalmente, você precisa de afinidade de sessão, um armazenamento de sessão compartilhado, ou um gateway fazendo inspeção profunda de pacotes — parseando corpos JSON para rotear requisições. Um servidor MCP que deveria ser um serviço HTTP comum fica sobrecarregado com um aparato sob medida de sistemas distribuídos. Quem faz a implantação acaba pagando por problemas que o próprio protocolo criou.

Imposto dois: a negociação de capacidades mata o cache. Como as listas de capacidades eram trocadas uma vez por conexão, os resultados das listas variavam por conexão. Cachear entre sessões ou via middleware compartilhado se tornava impossível de raciocinar — esse resultado de tools/list ainda é válido para o próximo cliente? Para sistemas de produção que dependem de caches para reduzir latência e custos de tokens, isso é fatal.

O objetivo dos mantenedores era explícito, com seis propostas de aprimoramento de especificação (SEPs) apontando todos na mesma direção: tornar cada requisição autônoma. O enquadramento oficial é um princípio de “complexidade sob demanda” (pay-as-you-go) — o núcleo permanece enxuto, e lógica com estado aparece apenas quando uma funcionalidade genuinamente a exige.

Protocolo Stateless, Aplicação Stateful

A objeção imediata: muitos servidores realmente precisam de memória — carrinhos de compra, estado de tarefas, sessões de conta. O que acontece com eles?

A resposta: o protocolo não gerenciar estado não significa que as aplicações não possam. Quando um servidor precisa de estado entre chamadas, ele usa o padrão que o HTTP vem amadurecendo há vinte anos — identificadores explícitos. Uma ferramenta gera um basket_id, o retorna no resultado, e o modelo o repassa como um parâmetro comum na próxima chamada. Estado de conta, URIs de recursos, identificadores de tarefas, identificadores de banco de dados — todos viajam por esse caminho.

Os mantenedores argumentam que isso é mais forte que sessões: o estado de sessão enterrado em metadados de transporte é invisível para o modelo, mas um identificador dentro do resultado de uma ferramenta pode ser composto entre ferramentas, passado entre etapas de um workflow e raciocinado. Identificadores são legíveis para o modelo; sessões são caixas-pretas — exatamente a transparência que cenários de agentes precisam.

O custo é igualmente explícito: identificadores aparecem em prompts, transcrições e logs, então devem estar vinculados a um principal autenticado e validados quanto à permissão a cada uso. Um identificador nunca é, por si só, uma credencial de autorização.

Os Efeitos Cascata de Ficar Stateless

O corte vai muito além de uma implantação mais simples; o modelo de operação do ecossistema muda junto:

• Implantação e gateways: servidores MCP remotos agora rodam como serviços HTTP stateless comuns — atrás de um balanceamento de carga round-robin simples, três réplicas, zero configuração. Implantações rolling não quebram mais sessões. Os novos headers de requisição Mcp-Method e Mcp-Name permitem que gateways apliquem rate limiting e autorização por operação sem parsear corpos de requisição — a menos que um chamador ignore as regras de validação de transporte, um header aparentemente inofensivo não pode esconder outra chamada por baixo dele.
• Cache: finalmente inferível e faturável. Resultados de listagem e leitura afetados devem carregar ttlMs e cacheScope (modelado no Cache-Control do HTTP), para que os clientes possam reter diretórios pelo intervalo declarado em vez de buscá-los novamente. A especificação também exige que os servidores retornem entradas em ordem determinística — servindo diretamente às taxas de acerto de prompt-cache, o que em escala significa menor latência e menor gasto com tokens.
• Camadas do ecossistema: um núcleo enxuto, extensões em cadência própria. As extensões oficiais vivem no namespace io.modelcontextprotocol, e as extensões de terceiros no domínio reverso do autor, cada uma com repositórios e ciclos de release independentes. Quem já escreveu custom resources do Kubernetes reconhecerá o padrão — funcionalidades amadurecem fora do trem de releases do núcleo.
• Uma política de deprecação que acalma o ecossistema: toda funcionalidade agora tem um ciclo de vida definido — ativa, descontinuada, removida — com um período mínimo de transição de 12 meses a partir da primeira marcação de deprecação; apenas risco de segurança ativo encurta esse prazo, e 90 dias é o piso absoluto. Registros públicos listam as remoções futuras. Rotina para desenvolvedores, mas para quem precisa justificar a integração do MCP a um comitê de revisão de plataforma, uma garantia de deprecação por escrito vale mais do que qualquer funcionalidade nova.

Os custos também são reais: sistemas construídos sobre a API experimental de Tasks precisam migrar; servidores em modo de requisição autônoma migram para o modo multi-round-turn request (MRTR); e o sampling é a deprecação mais espinhosa — antes, o sampling mediado pelo cliente significava que os servidores não precisavam de credenciais de provedor nem carregavam a conta dos modelos; chamar APIs diretamente os torna detentores de credenciais e pagadores de contas. E o stateless entrega roteabilidade, não determinismo: duas réplicas recebendo requisições idênticas ainda podem responder de forma diferente se rodarem versões diferentes ou lerem dados distintos downstream.

O Que Fazer Agora

O candidato está congelado, a especificação final publicada, a janela de validação de dez semanas está aberta, e os SDKs beta para Python, TypeScript, Go e C# estão prontos. O caminho de migração está definido: os clientes sondam primeiro com server/discover e fazem fallback para initialize quando um servidor suporta apenas o protocolo antigo. Esta é uma mudança que quebra compatibilidade — mas com um caminho de transição negociável, não uma data de corte forçada para todo o ecossistema.

• Desenvolvedores de servidores: implante servidores MCP remotos como serviços HTTP stateless — balanceamento round-robin, sem armazenamentos de sessão, políticas de gateway baseadas no header Mcp-Method. Para estado entre chamadas, adote identificadores explícitos com validação de permissão adequada.
• Equipes de plataforma e operações: use os novos headers para rate limiting e autorização sem parsing; adicione ttlMs / cacheScope aos resultados de listagem e leitura; audite dependências de sessão e teste implantações rolling durante a janela de validação — não sob tráfego de produção.
• Decisores de arquitetura: leia esta revisão como um sinal de maturidade. O protocolo começou a ser tão “chato” quanto o HTTP — o que é precisamente o que o torna pronto para o enterprise. Uma garantia de deprecação por escrito, um mecanismo de evolução de extensões e operação em infraestrutura commodity são as três frases que todo comitê de revisão de plataforma quer ouvir.

Então, por que o MCP “regrediu” à antiga era do HTTP? A resposta está na direção da evolução. Um protocolo projetado para processos locais trata sessões como funcionalidades; em um mundo de produção remoto, escalado horizontalmente e multi-tenant, sessões são um passivo. Cortá-las não é nostalgia de quem corta âncoras — é o MCP finalmente crescendo para se tornar o que sempre deveria ter sido: tão simples quanto o HTTP, tão escalável quanto o HTTP.

Há dois anos, o MCP definiu como a IA se conecta a ferramentas. Esta revisão define como a infraestrutura que conecta IA a ferramentas deve ser operada. A primeira estabeleceu o teto do ecossistema; a segunda decide até onde o ecossistema pode ir.