Especificação Final do MCP Enviada. Agora Precisa de Governança SRE

O Protocolo de Contexto do Modelo enviou sua especificação final em 28 de julho de 2026 — adicionando extensões de Tarefas e Aplicativos MCP, com o LangGraph 1.0 tratando as ferramentas MCP como nós de gráfico de primeira classe e a Netzilo enviando chaves de desligamento de tempo de execução multiplataforma para agentes comprometidos.

O MCP deixa de ser um protocolo experimental hoje. É uma infraestrutura de produção.

A infraestrutura de produção precisa de governança SRE. Aqui está como isso se parece para o MCP.

O que mudou na especificação final

A especificação final do MCP introduz duas extensões que mudam significativamente a imagem de confiabilidade:

Tarefas: Operações de longa duração agora são um primitivo de primeira classe no MCP. Um agente pode iniciar uma tarefa, o servidor MCP a executa de forma assíncrona, e o resultado está disponível quando concluído. Isso não é uma solução alternativa — é o comportamento especificado. As tarefas agora podem ser executadas por minutos ou horas de forma autônoma sem que o agente faça polling.

Aplicativos MCP: Uma maneira padronizada para os servidores MCP exporem componentes de UI juntamente com chamadas de ferramentas. Os agentes agora podem interagir com interfaces estruturadas, não apenas com retornos de função brutos.

A implicação de confiabilidade de ambos: o MCP não é mais um protocolo de solicitação-resposta com latência em escala humana. É uma camada de orquestração para trabalho autônomo de longa duração.

As quatro lacunas de SRE que chegam com a especificação final

1. Cada ferramenta MCP precisa de um SLO

A confiabilidade do seu agente é limitada pela pior servidor MCP que ele chama. Um agente que chama cinco ferramentas MCP tem cinco SLOs de dependência. Se qualquer um falhar silenciosamente — retornando um formato inesperado, expirando sem um erro, retornando dados desatualizados — a Taxa de Qualidade de Decisão do seu agente se degrada sem um sinal na camada de infraestrutura.

Instrumente a Eficiência de Invocação de Ferramentas por servidor MCP, não apenas por classe de tarefa:

from agentsre import AgentSLICollector, TaskRecord

collector = AgentSLICollector()

# Rastrear por servidor MCP — não apenas por tarefa
for mcp_server, tool_calls in mcp_trace.server_calls.items():
    collector.record(TaskRecord(
        task_id=task_id,
        task_class=f"mcp:{mcp_server}",   # rastreamento por servidor
        tool_calls=tool_calls,
        decision_confidence=task_confidence,
        completed=task_completed,
    ))

# Cada servidor MCP recebe sua própria linha de base TIE e alerta de violação
results = collector.collect(f"mcp:{mcp_server}")

Isso lhe dá linhas de base comportamentais por servidor MCP. Quando um servidor específico começa a gerar contagens elevadas de chamadas de ferramentas — tempestades de tentativas, mudanças de formato, degradação de latência — o TIE captura isso antes que surja como uma falha de tarefa.

2. Disjuntor MCP na Fronteira

Quando uma ferramenta MCP falha, o que seu agente faz? A maioria das estruturas tenta novamente. A lógica de nova tentativa sem um disjuntor na fronteira do MCP produz tempestades de tentativas — o agente chama uma ferramenta com falha repetidamente, o TIE sobe silenciosamente, e o primeiro sinal observável é um pico de custo.

Aplicar o disjuntor na camada de chamada MCP:

from agentsre import AgentChainCircuitBreaker

# Disjuntor por servidor MCP
mcp_breakers = {
    server_name: AgentChainCircuitBreaker(
        open_threshold=85.0,    # abrir se a taxa de sucesso semântico cair abaixo de 85%
        close_threshold=95.0,   # fechar após recuperação
        on_state_change=lambda state: alert_mcp_server_owner(server_name, state),
    )
    for server_name in mcp_servers
}

def call_mcp_tool(server_name: str, tool: str, params: dict):
    breaker = mcp_breakers[server_name]

    if not breaker.allow_request(