Se você já usou um agente de IA para preencher um formulário, reservar um voo ou buscar um produto em um e-commerce, sabe que a experiência costuma ser frustrante. O agente clica no lugar errado, não encontra o botão certo, interpreta mal um campo de texto. Isso acontece porque a web foi construída para humanos, não para máquinas que tentam simular comportamento humano.

Em fevereiro de 2026, o Google lançou em early preview o WebMCP (Web Model Context Protocol), um novo padrão que propõe uma mudança radical nessa dinâmica. Em vez de agentes tentando adivinhar como usar um site, o próprio site declara suas capacidades como ferramentas estruturadas que qualquer agente pode invocar diretamente.

O problema: agentes de IA navegam a web como turistas perdidos

Hoje, quando um agente de IA precisa interagir com um site, ele tem basicamente duas estratégias. A primeira é visual: tirar screenshots da página e tentar interpretar o que está na tela usando modelos multimodais. A segunda é manipulação de DOM: navegar pela estrutura HTML, localizar elementos por seletores CSS ou XPath, e simular cliques e digitação.

Ambas as abordagens são frágeis. Uma mudança no layout, um botão que muda de posição, um popup inesperado — qualquer alteração cosmética pode quebrar todo o fluxo. É como tentar operar uma máquina complexa olhando pela janela em vez de ter acesso ao painel de controle.

O resultado prático é que agentes gastam tempo e tokens processando informação visual redundante, falham em tarefas simples como preencher um formulário de duas etapas, e precisam de manutenção constante quando os sites atualizam seu design.

WebMCP: o protocolo que transforma sites em toolkits estruturados

O WebMCP inverte a lógica. Em vez de o agente precisar entender a interface visual do site, o site expõe um catálogo de ferramentas com nomes, descrições e schemas de entrada bem definidos. O agente consulta esse catálogo, escolhe a ferramenta certa e a invoca passando os parâmetros estruturados.

Na prática, funciona assim:

  1. O desenvolvedor marca formulários e ações do site como ferramentas WebMCP
  2. O navegador detecta essas ferramentas e as disponibiliza via API navigator.modelContext
  3. Um agente compatível descobre as ferramentas disponíveis na página
  4. O agente invoca a ferramenta passando parâmetros em JSON
  5. O site executa a ação e retorna o resultado estruturado

O padrão está sendo desenvolvido pelo W3C Web Machine Learning Community Group, com participação ativa do Google e da Microsoft. A especificação foi formalmente aceita como deliverable do grupo em setembro de 2025, e a primeira implementação no navegador chegou com o Chrome 146 Canary em fevereiro de 2026.

O WebMCP oferece duas APIs complementares para cobrir cenários diferentes: uma declarativa para casos simples e uma imperativa para fluxos complexos.

API Declarativa: dois atributos HTML e seu form vira uma ferramenta

A API Declarativa é a forma mais rápida de tornar um site compatível com agentes. Se você já tem formulários HTML funcionando, o trabalho é adicionar alguns atributos.

Veja um formulário de login convencional transformado em ferramenta WebMCP:

<form
  id="login-form"
  toolname="login"
  tooldescription="Fazer login na aplicação com email e senha"
  toolautosubmit="true"
>
  <label for="email">Email</label>
  <input
    type="email"
    id="email"
    name="email"
    required
    toolparamtitle="Email"
    toolparamdescription="Endereço de email do usuário"
  />

  <label for="password">Senha</label>
  <input
    type="password"
    id="password"
    name="password"
    required
    toolparamtitle="Senha"
    toolparamdescription="Senha da conta do usuário"
  />

  <button type="submit">Entrar</button>
</form>

Os atributos principais são:

  • toolname — identifica a ferramenta (obrigatório para tornar o form visível a agentes)
  • tooldescription — descreve o que a ferramenta faz em linguagem natural
  • toolparamtitle e toolparamdescription — documentam cada campo individualmente
  • toolautosubmit — quando true, o form é submetido automaticamente após o agente preencher os campos

O navegador cuida do resto: quando um agente compatível detecta o formulário, ele lê a descrição, entende os parâmetros esperados e preenche os campos com dados estruturados. O CSS oferece a pseudo-classe :tool-form-active para estilizar formulários durante interação com agentes, e o evento SubmitEvent.agentInvoked permite distinguir submissões feitas por humanos das feitas por agentes.

A recomendação dos criadores da spec é direta: todo formulário deveria ser declarado como WebMCP. O esforço é mínimo — dois ou três atributos HTML — e o benefício é que agentes vão interagir com seu site de forma confiável em vez de tentar scraping.

API Imperativa: controle total com JavaScript

Para ações que não são formulários — logout, navegação contextual, operações dinâmicas que dependem de estado — existe a API Imperativa. Ela expõe o método navigator.modelContext.registerTool() para registrar ferramentas programaticamente.

Um exemplo de ferramenta que busca produtos com filtros:

navigator.modelContext.registerTool({
  name: "search_products",
  description: "Buscar produtos no catálogo com filtros de categoria, preço e avaliação",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Termo de busca do produto"
      },
      category: {
        type: "string",
        description: "Categoria do produto (roupas, eletrônicos, casa)"
      },
      maxPrice: {
        type: "number",
        description: "Preço máximo em reais"
      },
      minRating: {
        type: "number",
        description: "Avaliação mínima de 1 a 5"
      }
    },
    required: ["query"]
  },
  async execute(args) {
    const results = await fetchProducts(args);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(results)
      }]
    };
  }
});

A estrutura segue o padrão familiar de function calling que já existe em APIs de LLMs: nome, descrição em linguagem natural, schema JSON para os parâmetros de entrada, e uma função execute que recebe os argumentos e retorna o resultado.

A diferença fundamental é que isso roda dentro do navegador, no contexto da página. A ferramenta tem acesso ao DOM, ao estado da aplicação, às APIs do browser — tudo que um script JavaScript normal teria. Isso significa que o desenvolvedor reaproveita código frontend existente em vez de precisar criar uma camada de API separada para agentes.

WebMCP vs MCP da Anthropic: client-side vs server-side

É fácil confundir WebMCP com o Model Context Protocol (MCP) da Anthropic, já que os nomes são parecidos e ambos tratam da comunicação entre agentes de IA e serviços. Mas eles operam em camadas completamente diferentes.

O MCP da Anthropic é um protocolo server-side. Ele conecta plataformas de IA (como Claude, GPT ou modelos open source) a provedores de serviço através de integrações backend. Um servidor MCP expõe ferramentas que o modelo pode invocar via chamadas de rede, com transporte por stdio ou Server-Sent Events (SSE). O modelo não precisa de um navegador — ele conversa diretamente com o servidor.

O WebMCP é client-side. Ele roda inteiramente dentro de uma aba do navegador. As ferramentas são definidas pelo site e expostas para agentes que operam no contexto do browser. O agente, o site e o usuário compartilham o mesmo contexto visual — o que permite workflows onde o humano supervisiona e intervém quando necessário.

Essa diferença arquitetural cria uma complementaridade interessante:

  • MCP (backend) resolve integrações entre sistemas: conectar um agente ao Slack, ao GitHub, a um banco de dados, a uma API interna
  • WebMCP (frontend) resolve interações com interfaces web: navegar sites, preencher formulários, executar ações em aplicações web

Um agente robusto provavelmente vai usar ambos: MCP para acessar serviços de backend e WebMCP para interagir com aplicações web que só existem como interfaces de usuário.

Implicações para desenvolvedores e o futuro da web

O WebMCP não é apenas um protocolo técnico — ele sinaliza uma mudança estrutural na web. Assim como o surgimento do SEO criou uma disciplina inteira em torno de tornar sites descobríveis por mecanismos de busca, o WebMCP pode criar um equivalente para agentes de IA.

Algumas implicações práticas:

Agentic SEO está nascendo. A qualidade das descrições de ferramentas, a clareza dos schemas e a confiabilidade das execuções vão determinar quais sites os agentes preferem usar. Da mesma forma que meta descriptions influenciam taxa de clique no Google, tool descriptions vão influenciar a taxa de invocação por agentes.

Sites sem WebMCP podem se tornar invisíveis para fluxos automatizados. Se um agente pode escolher entre um e-commerce com ferramentas estruturadas e outro que exige scraping frágil, a escolha é óbvia. O investimento para implementação é baixo — principalmente para a API Declarativa — mas a penalidade por não adotar pode ser significativa.

O modelo de segurança é explícito por design. Apenas formulários e ações marcados pelo desenvolvedor ficam visíveis para agentes. Isso é diferente de scraping, onde qualquer elemento da página pode ser manipulado. O CSS pseudo-class :tool-form-active e o SubmitEvent.agentInvoked permitem que o site trate interações de agentes de forma diferente, aplicando validações extras ou rate limiting.

Independência de modelo. Apesar de o Google liderar o desenvolvimento e a demo usar Gemini 2.5 Flash, o WebMCP é um padrão web aberto. Qualquer modelo — Claude, GPT, LLaMA, ou modelos open source — pode consumir ferramentas WebMCP desde que opere através de um navegador compatível.

O padrão ainda está em early preview (Chrome 146 Canary, atrás de flag experimental), mas o envolvimento do W3C, Google e Microsoft na especificação indica que a adoção por browsers mainstream é questão de tempo.

Conclusão

O WebMCP resolve um problema real e crescente: a incompatibilidade entre sites projetados para humanos e agentes de IA que precisam interagir com eles. Em vez de forçar agentes a fazer engenharia reversa de interfaces visuais, o protocolo permite que sites declarem suas capacidades como ferramentas invocáveis.

Para desenvolvedores, a barreira de entrada é baixa. A API Declarativa exige apenas atributos HTML extras em formulários existentes. A API Imperativa oferece flexibilidade total para ações complexas via JavaScript. E a independência de modelo garante que o investimento vale independente de qual agente seus usuários vão usar.

A web está se preparando para uma segunda camada de consumidores — não mais apenas humanos com navegadores, mas agentes autônomos executando tarefas em nome de pessoas. O WebMCP é a ponte entre esses dois mundos, e quem construir essa ponte primeiro sai na frente.

Referências pesquisadas nesta publicação