Chrome shipped a browser standard in February 2026 that nobody talked about. Most B2B sites won't notice it for another 18 months. We shipped a production integration on inigra.eu this week. Here's why we did it now, what it cost, and why your team should consider the same.
The release nobody talked about
WebMCP — Web Model Context Protocol — is Chrome's new browser standard that lets your website expose tools directly callable by AI agents. Instead of an agent scraping your HTML and guessing at structure, your page declares: "here's what I can do — call get_pricing(), call search_case_studies(), call book_call()."
The agent doesn't scroll. Doesn't burn 5,000 LLM tokens parsing 200KB of HTML. Doesn't hallucinate when your design changes. It calls a function with a JSON schema and gets back canonical data in 100 milliseconds.
Chrome released WebMCP in February 2026 as part of the Early Preview Program. The official spec lives on GitHub under W3C's Web Machine Learning Community Group. Today, support is limited to Chrome (with the right flags or EPP enrollment) and a small handful of MCP-aware browsers and extensions — Claude for Chrome, ChatGPT Operator, Perplexity Comet.
That's exactly why we shipped it now.
The "ship now" thesis
If you've been in software long enough, you've seen this pattern before:
- 2012 — Mobile-friendly websites. Most teams ignored it. Google made it a ranking factor in 2015. The teams who shipped early got 18 months of compounding SEO advantage.
- 2017 — HTTPS by default. "We don't need it, we're not handling sensitive data." Then Chrome started flagging non-HTTPS sites as "Not Secure." Search penalty followed.
- 2021 — Core Web Vitals. Most sites ignored LCP, CLS, INP for a year. Google made them a ranking signal. Sites that had already optimized went to the top.
Each cycle: browsers signaled what they wanted, ~18 months later search ranking rewarded those who listened.
WebMCP is the next signal. Three reasons it matters faster than the previous waves:
1. AI search already prefers structured data
Google AI Mode, Perplexity, ChatGPT Search — all of them favour sites with structured data (JSON-LD, schema.org markup, clean APIs). WebMCP is the next step on the same axis: from "structured markup" to "structured callable interfaces."
And it's not just about ranking. Every tool call replaces an HTML scrape that costs the AI provider ~25× more in LLM tokens. Anthropic and OpenAI have direct economic incentive to favour MCP-ready sites. As agent traffic grows, this preference will harden into a routing decision.
2. Action tools change conversion math
Read-only tools (the kind we shipped) save the agent some scraping. That's marginal value today.
The real prize is action tools. book_discovery_call(). add_to_cart(). configure_product(). On bookings, e-commerce, configurators — this is the difference between "agent fills your form for 30 seconds" and "agent books in 1 second."
We deferred action tools for now (more on that in a minute). But the infrastructure is ready. When the security model matures, flipping the switch is a one-day job.
3. Pattern matching
By the time WebMCP ranking signals are documented in Google's search guidelines, the early-adopter window will be closed. Three months in, almost nobody has shipped this. Twelve months in, your competitors will be scrambling. Eighteen months in, it's a hygiene factor.
The compound advantage is real. So is the cost of waiting.
What we shipped on inigra.eu
Three read-only tools, registered via the navigator.modelContext.registerTool() API:
inigra_list_case_studies({ industry?, technology?, limit? })— returns matching projects from our portfolioinigra_get_pricing({ project_type?, currency? })— returns 3 MVP tiers in GBP or USDinigra_search_blog({ query, limit? })— searches our blog by title and summary
Backed by static JSON endpoints under /api/ that work for any AI crawler, not just MCP-aware ones — Google AI Mode, Perplexity, ChatGPT Search can read them today. The JS feature-detects WebMCP and gracefully no-ops in browsers that don't support it. Zero impact on PageSpeed (we held our 98/100 mobile score). Zero risk to existing functionality.
You can test it: open Claude for Chrome, visit inigra.eu/portfolio, and ask: "What FinTech projects has Inigra done?" — Claude calls inigra_list_case_studies({ industry: "FinTech" }) directly, no scrolling, no scraping.
The dirty secret: 20 minutes
Here's the part that makes most engineers uncomfortable.
The actual coding — the JavaScript that registers three tools, the JSON endpoints, the feature detection — took about 20 minutes. AI-assisted development reduced what would have been a half-day task to roughly the time it takes to make a coffee and answer two Slack messages.
If that's the whole story, the headline is "AI replaces engineers." But that's not the whole story. Here's what actually happened:
- 30 minutes reading the WebMCP proposal, mapping the API surface, validating Chrome support status
- 20 minutes of AI-assisted implementation
- 2 hours deciding what not to expose
That last one is the whole game.
What we deliberately did not ship
The most valuable WebMCP tool we could have built was inigra_book_discovery_call({ name, email, budget, urgency }). One function call, agent books a meeting, conversion in a second.
We didn't ship it. Here's why.
Action tools without rate limiting and abuse prevention are spam vectors waiting to happen. The first time a malicious agent script discovers inigra_book_call() and starts firing 1,000 fake bookings a minute, it doesn't just clog our calendar — it signals to Anthropic, Google, and the rest of the agent ecosystem that our domain is a low-quality target. We lose more in trust than we gain in convenience.
Senior judgement says: defer the high-value action tool until the security model is mature. Ship the read-only tools now to plant the flag, evolve the rest as the spec stabilises.
This is the kind of decision AI doesn't make for you. The model will happily generate inigra_book_call() with no rate limit, no consent flow, no anti-abuse layer. Then your CRM gets flooded and you're firefighting at 2am.
Human expertise. AI efficiency. You need both. The 20-minute build was AI. The 2-hour "don't ship that yet" conversation was human. Neither alone delivers the result.
How this applies to your industry
WebMCP isn't only useful for software houses. The pattern — 2–3 read-only tools to plant the flag, 1 action tool when your security model can defend it — works across every B2B vertical. A few concrete starting points:
E-commerce / Retail
search_products({ query, max_price, in_stock })— agent narrows your catalog without scraping product pagescheck_inventory({ sku, postcode })— real-time stock + delivery window in one call- Action tier:
add_to_cart,apply_discount_code— agent completes purchase intent end-to-end
SaaS
get_pricing_tier({ users, features })— quote that matches actual usage, not a generic "starting at $99"check_integration({ tool_name })— does this work with my Salesforce / HubSpot / Slack stack?- Action tier:
start_trial({ email })— agent provisions a trial during a research call
Real estate / Property
search_listings({ city, budget, rooms, type })— agent filters your portfolio against client briefget_property_details({ id })— pulls floorplan, amenities, price history in structured form- Action tier:
book_viewing({ id, datetime, contact })— inspections booked from inside the agent flow
Hospitality / Restaurants / Venues
check_availability({ datetime, party_size })— real-time table or room statusget_menu({ dietary, allergens })— instant filter by client need- Action tier:
book_table/book_room— reservations without web-form friction
Healthcare / Clinics
find_specialist({ condition, city })— semantic match across your staff and locationscheck_insurance_accepted({ provider })— eligibility upfront, before the patient calls- Action tier:
book_consultation({ doctor_id, datetime })— booking inside the agent conversation
Financial services / Lending
calculate_loan({ amount, term })— quick estimate without forcing a form fillcheck_eligibility({ income, criteria })— pre-qualifying signal returned in seconds- Action tier:
schedule_advisor_call({ topic, time })— book a human follow-up
Professional services (legal, accounting, consulting)
search_practice_areas({ keyword })— agent matches client need to your specialismget_consultant_availability({ specialty, week })— clean calendar slots- Action tier:
book_consultation({ topic, datetime })— qualified intro calls without back-and-forth
Travel / Booking platforms
search_options({ from, to, dates })— agent narrows down without scraping listing pagescheck_price({ option_id, dates })— real-time price quote- Action tier:
create_booking({ option_id, traveller, payment_method })— full transaction inside the agent
Notice the pattern: read-only tools answer "what do you have / what does it cost?" Action tools answer "do it for me."
Read-only is safe to ship today on almost any B2B site. Action tools need rate-limiting, abuse prevention, and an audit log — but the upside (compressing a 30-second form fill into a 1-second function call) is the prize that justifies the work.
What to do today (under 1 hour)
If you run a B2B website and want to ship a defensible WebMCP integration this week, here's the minimum:
- Pick 2–3 read-only tools. Things AI agents would naturally want from your site: list_products, get_pricing, search_articles, get_office_hours. Skip anything that mutates state.
- Build static JSON endpoints behind those tools.
/api/products.json,/api/pricing.json, etc. These work for every AI crawler today (Google AI Mode, Perplexity, ChatGPT Search) — not just WebMCP-aware browsers. - Add a small JS file that feature-detects
navigator.modelContext, registers the tools, and gracefully no-ops elsewhere. ~7KB. - Don't ship action tools yet. Wait for the spec to define rate-limiting and consent primitives. Or build them yourself — but only if you have the security review bandwidth.
- Test with Claude for Chrome. Open the extension, navigate to your site, ask a natural question that maps to one of your tools. If Claude calls the tool, you've shipped.
Total time with AI assistance: under an hour for an experienced web developer. Strategic thinking time: longer than that, and worth it.
The window is open
By Q1 2027, "WebMCP-ready" will be on every B2B SaaS competitive checklist. By mid-2027, it'll show up in Google's search ranking guidelines.
You can be the team that shipped early — or the team that scrambles in 12 months when a prospect asks "why doesn't your site work properly when I research it through Claude?"
We chose early. The brand position writes itself.
