Something shifted this week, and most B2B companies missed it entirely.

Google shipped WebMCP in Chrome 146's early preview — a new W3C standard that lets AI agents interact with websites through structured tools instead of guessing at buttons and scraping text off screens. When a VP of Sales asks Claude or Gemini to “find me a visitor identification tool under $2K a month and book a demo,” the agent that gets dispatched to your website isn't admiring your hero image or reading your testimonials. It's trying to parse your DOM, locate the pricing data, figure out which button triggers a booking flow, and extract something structured from a page that was built entirely for human eyes.

WebMCP changes that equation. And we just implemented it across meetcursive.com.

What WebMCP Actually Is

WebMCP stands for Web Model Context Protocol. It's a joint W3C standard developed by Google and Microsoft that gives websites a way to publish a structured “tool menu” that AI agents can call directly — no screen parsing, no DOM guessing, no visual interpretation of pixel layouts.

The mental model is simple. Today, when an AI agent visits your website, it takes a screenshot, runs it through a vision model, tries to identify clickable elements, and attempts to navigate your site the way a confused human would. It's slow, expensive (each screenshot costs tokens), and fragile — a minor design change can break the entire flow. WebMCP replaces that entire pipeline with a single structured function call.

The standard exposes two APIs. The Declarative API lets you add attributes directly to existing HTML forms — toolname, tooldescription, toolparamdescription — so agents understand what each form does and what each field expects without guessing. The Imperative API lets you register JavaScript functions as callable tools via navigator.modelContext.registerTool(), where agents call your functions and get clean JSON back.

The result is a 67% reduction in computational overhead compared to visual agent approaches. One function call replaces dozens of browser interactions. And it's model-agnostic: Claude, Gemini, ChatGPT, or any browser-based agent that supports the standard can call the same tools.

Dan Petrovic, a technical SEO researcher, called it “the biggest shift in technical SEO since structured data.” He's not wrong. Just as schema.org markup let search engines understand your pages without parsing natural language, WebMCP lets AI agents understand your product without parsing pixels.

Why This Matters for Lead Generation

Here's the thesis: the buyer's journey is going agentic.

Think about how enterprise software gets evaluated today. A VP of Marketing needs a visitor identification platform. They ask their team to research options. Somebody spends three hours opening tabs, comparing pricing pages, reading G2 reviews, and building a spreadsheet. That process is already being delegated to AI assistants, and WebMCP accelerates the transition by making it dramatically more reliable.

When that agent visits multiple vendor websites, something interesting happens. The site that exposes structured tools — pricing, feature comparisons, capability breakdowns, demo booking — as callable functions gives the agent a clean, reliable path. The agent calls getCursivePricing, gets structured JSON with every tier, every feature, every price point. It calls compareCursiveToCompetitor with “ZoomInfo” and gets a feature-by-feature breakdown. It calls bookCursiveDemo and gets a cal.com URL it can present to the human. Total time: seconds.

The site that doesn't implement WebMCP forces the agent to screenshot the pricing page, try to parse a grid of cards with CSS gradients, hope the toggle between “monthly” and “annual” billing is clickable, and extract numbers from decorative typography. That's slower, more expensive, and more error-prone. When agents are comparing five vendors on behalf of a prospect, they'll naturally prefer the structured path.

Now consider what Cursive already does. We track when humans visit your website and identify them in real-time — name, company, email, pages viewed. We turn anonymous traffic into actionable pipeline. The same principle applies to agentic traffic. When an AI agent visits your pricing page on behalf of a prospect, that visit is a signal of intent. The prospect is actively evaluating. The company that sees that signal and responds first wins the deal.

The competitive moat here is real. In a world where agents do the initial vendor evaluation, the first company in each category to implement WebMCP has a structural advantage. The agent experience becomes an optimization surface — just like SEO was for search engines in 2008, just like mobile responsiveness was for Google's mobile-first index in 2016. The companies that ignore it don't disappear overnight, but they fall behind steadily as more buyer journeys start with an AI assistant rather than a Google search.

What We Built

We didn't just add a few meta tags. We built a comprehensive agent interface across meetcursive.com that exposes Cursive's entire value proposition as structured, callable tools.

Six Imperative WebMCP Tools

These are JavaScript functions registered via navigator.modelContext.registerTool() that any browser-based AI agent can call directly:

getCursivePricing returns structured pricing for both our self-serve marketplace (credit packages from $0.60/lead) and managed service tiers (Data at $1,000/mo, Outbound at $2,500/mo, Pipeline at $5,000/mo), including annual discounts, feature lists, and signup URLs.

compareCursiveToCompetitor accepts a competitor name and returns a feature-by-feature comparison. We currently support ten competitors: ZoomInfo, Apollo, Clearbit, 6sense, Warmly, RB2B, Leadfeeder, Demandbase, Instantly, and Smartlead. Each comparison includes identification rates, starting prices, whether AI outreach is included, and a link to our detailed comparison page.

getCursiveCapabilities returns a structured overview of the platform across six product categories: visitor identification, intent data, AI outreach, audience builder, direct mail, and integrations.

bookCursiveDemo returns a cal.com booking URL with context about what to expect on the call, plus alternative actions like the free audit and marketplace signup.

getCursiveResults serves case study data filterable by metric type — revenue generated, ROAS, pipeline created.

getCursiveIndustries returns industry-specific use cases and landing page URLs for nine verticals, from B2B software to financial services to media and advertising.

Here's what the competitor comparison tool registration looks like in practice:

navigator.modelContext.registerTool({
  name: "compareCursiveToCompetitor",
  description: "Compare Cursive against competitors like ZoomInfo, Apollo, Clearbit...",
  inputSchema: {
    type: "object",
    properties: {
      competitor: {
        type: "string",
        description: "Competitor name (e.g., ZoomInfo, Apollo, Clearbit)"
      }
    },
    required: ["competitor"]
  },
  annotations: { readOnlyHint: true },
  execute: async (params) => {
    // Returns structured comparison data as JSON
    return {
      cursive: { visitor_id_rate: "70%", starting_price: "$1,000/mo", ... },
      competitor: { name: params.competitor, visitor_id_rate: "~30-40%", ... },
      full_comparison_url: "https://www.meetcursive.com/blog/..."
    }
  }
})

One function call. Structured input, structured output. No screenshots, no DOM parsing, no guessing which card contains which tier.

Declarative Forms

We annotated seven existing forms across the site with WebMCP declarative attributes. Our contact form, free audit request, custom audience builder, exit-intent popups, newsletter subscription, and pricing tier selector all carry toolname and tooldescription attributes on the form element, with toolparamdescription on each input. An agent encountering our contact form doesn't have to guess what “Message” means — it reads the attribute and knows it's for “a message describing what you need help with (e.g., demo request, pricing question, partnership inquiry).”

Supporting Infrastructure

WebMCP tools are the headliner, but agent discoverability requires a full stack. We also ship:

An llms.txt file at the site root — the emerging standard (think robots.txt for AI) that tells language models what the site is about, what tools are available, and where to find structured data.

A /api/ai-info endpoint that returns Cursive's complete product information as a single JSON response. Any LLM or agent can fetch this URL and get products, services, pricing, stats, customer results, and available WebMCP tools in one request, cached for one hour. This works regardless of whether the agent supports WebMCP — it's just HTTP.

JSON-LD structured data across every key page: Organization and SoftwareApplication schemas on the homepage, Product and FAQPage schemas on pricing, Service schemas on the services page, and BlogPosting schemas on every article.

Semantic HTML with section IDs on the homepage (#hero, #products, #pricing, #case-studies, #industries, #faq) so agents can navigate directly to relevant sections without scrolling through the entire page.

What This Means for Your Website

AI agents are already visiting your website. Per Imperva's 2025 report, 51% of web traffic is now automated. Most of that is traditional bots, but the share attributable to AI agents — LLMs dispatched to browse, evaluate, and take action on behalf of humans — is growing fast. The question isn't whether to optimize for agents. It's when.

If you want to start today, here's the practical path. First, create an llms.txt file and a /api/ai-info JSON endpoint. This takes thirty minutes and immediately gives any LLM a structured way to understand your product, independent of any browser standard. Second, if you have forms on your site — contact forms, demo requests, signup flows — add WebMCP declarative attributes. Another thirty minutes. Add toolname and tooldescription to the <form> element, name attributes to every input (you should have these already), and toolparamdescription where the field name alone isn't self-explanatory. Third, for real differentiation, register imperative tools that expose your product's core value proposition. What would a prospect's AI assistant want to ask? Pricing, comparisons, capabilities, how to get started. Those are your tools.

The companies that build their agent interface now will have the same advantage that early SEO adopters had in 2010. Not because Google is going to rank WebMCP-enabled sites higher (though structured data has historically correlated with better search visibility). But because when AI agents become a meaningful share of your website traffic — evaluating your product on behalf of prospects — the site that gives them a structured, reliable path will consistently outperform the site that forces them to guess.

See It in Action

If you want to see WebMCP working, visit meetcursive.com with Chrome 146 Canary and the Experimental Web Platform Features flag enabled. Open DevTools, check the console for “[WebMCP] Cursive tools registered successfully,” and install the Model Context Tool Inspector extension to see all six tools in the sidebar.

If you want Cursive to identify who's visiting your site — human or agent — book a free AI audit. We'll show you exactly which companies are on your site right now, what pages they're viewing, and how to reach them before your competitors do.

The agentic web is here. Your move.