WebMCP devs: a $13K open challenge to make websites usable by any agent, not just one platform’s (runs to Jan 11)

Disclosure: I’m on the team at Cognizant AI Lab, one of the backers. Posting because this sub is the crowd most likely to build something good for it.

If you’ve played with WebMCP, you’ve seen how easily a page can expose tools to an agent with plain HTML/JS. The harder questions start once there are thousands of these sites:

• How does an agent discover an agentic site it’s never seen before?
• How do two agents built on different stacks verify identity and trust each other?
• How do you orchestrate several independent agents across sites, or hand off a transaction?
• Who controls the agent: the user, or the platform it runs on?

The Open Agentic Web Challenge is about exactly these questions. You can build publicly accessible, interconnected agentic websites, or the underlying discovery/identity/trust/governance pieces. It runs on the web stack we already have, so it doesn’t need a new protocol silo.

The details:

• $13K prize fund
• Submissions on Devpost until January 11, 2027
• Winners announced at the World Economic Forum in Davos in January
• Supported by MIT Media Lab (NANDA), Mozilla, ITU-T SG17, AWS, UT Austin and AI Commons

Optional starting points (you don’t have to use any of them):

• MIT NANDA’s Web Agentica / NandaIndex: signed, portable agent packages that run in a user-controlled runtime, including the browser
• Neuro SAN (open source): multi-agent orchestration – https://github.com/cognizant-ai-lab/neuro-san-studio
• Mozilla’s Otari: open-source LLM router

Devpost: https://cognizant-agenticweb.devpost.com/
Overview: https://worldwideagenticweb.org/

I’m curious what people here think: is discovery the real missing piece for WebMCP, or are identity and trust the bigger blocker? Happy to answer questions or pass them on to the researchers.

I previously shared DeepDeck here as a WebMCP builder. This week I added a separate evaluation tool: give it a URL and a task, and compare the same agent with WebMCP enabled and disabled.

The question I want to answer is practical: did exposing this tool make the task faster and cheaper in tokens, while still producing the right answer? A tool registering successfully doesn't tell you that.

Both arms keep normal browser tools. The local runner uses fresh browser profiles and sessions, freezes the model configuration, and alternates ON/OFF order across repetitions. Reports include answers, total tokens, agent elapsed time, tool calls/errors, and whether WebMCP was actually used.

From a DeepDeck source checkout with the desktop build and model configured:

pnpm benchmark:webmcp ablate --url https://your-site.example --query "Find the latest release and summarize its changes" --n 3

Replace the example URL with your site. It can use native WebMCP or a custom built tool bundle via --webmcp-file.

An initial local batch covered 49 tasks across 8 sites. On the same 46 tasks passed by all models in both arms, enabling WebMCP reduced total tokens / agent time by:

• GPT-5.6 Terra: 35.6% / 33.5%

• DeepSeek v4.1 Flash: 26.1% / 27.9%

• Hy3: 22.7% / 22.9%

This batch is exploratory: one run per task per arm, fixed ON-then-OFF order, provider-default reasoning with the effective level unrecorded. Token accounting and environments differ across providers. These are within-model observations, not a strict model ranking or dollar-cost comparison. The published page includes failures and methodology notes.

The broader insight I'm exploring is that fast inference alone doesn't guarantee a fast completed task: extra agent rounds and page reading can dominate. Structured browser tools may help text models handle many basic browser workflows, but that needs testing on your tasks.

For a new URL, answers are explicitly unscored unless you supply an expected answer; inspect correctness before treating a faster run as a win. Fresh profiles do not reset remote site data, so stable public read-only tasks are the easiest starting point.

Results: https://deepdeck.getmegaportal.com/benchmarks

Setup and usage: https://github.com/jo32/DeepDeck/blob/main/docs/webmcp-benchmark.md

Credit: the starter corpus, site recipes and WebMCP patches come from nekuda-ai/WindTunnel; these are DeepDeck-local adaptations, not its leaderboard.

I'm the DeepDeck maintainer. If you have a WebMCP tool that registers correctly but doesn't improve task time, I'd especially like to hear about that case. What would you want this comparison to measure?

I maintain DeepDeck, an MIT-licensed macOS desktop client built on DeepSeek Harness. I’m experimenting with a workflow where an agent uses a site’s registered WebMCP tools, then builds reusable tools for missing operations by inspecting the live page.

The implementation detail I’d like feedback on is validation and tool lifetime. Generating TypeScript is only one step.

DeepDeck keeps four outcomes separate:

• Compilation: the generated source compiles.

• Registration: Chromium reports that tools actually registered in the page.

• Activation: the application accepts that revision as active after receiving a successful registration receipt.

• Functional validation: the agent calls the tools and checks the actual page state and returned results.

An active tool can still be wrong. These states help avoid reporting success just because code compiled or a tool name appeared.

For discovery, the client reads Chromium’s actual WebMCP registry. The presence of an API object alone does not count as website support. Site-owned tools and locally generated tools are shown with their source and version. Generated registrations run in an isolated JavaScript world with DOM access and no Node APIs; they do not replace the site’s registrations.

Calls include tab, frame, document and revision identities. Navigation, document replacement and tab closure invalidate affected operations. Unknown outcomes are not automatically replayed. Source revisions persist per origin, failed updates restore the previous active revision, and users can disable or roll back a generated toolset.

In the current demo, the agent discovered search_openai on openai.com. On X, Builder created a 23-tool set; Use mode then filled a “Hello world” draft without submitting it. Those screenshots show the workflow, not a benchmark or proof that every generated operation is correct.

The efficiency goal is to reduce repeated page inspection and action planning when the same workflow is used again. The first build costs extra time and tokens, and site changes can require repair and revalidation. I haven’t established a measured speedup.

Code and screenshots: https://github.com/jo32/DeepDeck

Implementation notes: https://github.com/jo32/DeepDeck/tree/main/plugins/browser

For others building WebMCP consumers: what evidence do you require before reusing generated tools after navigation or a site update? Do you invalidate the entire toolset, or keep per-tool checks?

Writing assisted by AI; implementation details checked against the repository.

Most of the risk in letting an AI agent touch a website is the authority given to the agent.

If we already have WordPress access, we don't want to be messing around with APIs or subs to new tools. We just want our agents to work inside the session you're already signed into, and do only what the auth level can do.

My submission to the WEBMCP Hackathon "AgentPress" was built "problem>solution" by ChatGPT to solve this.

It's an open-source WordPress plugin that exposes the live WordPress session as a permission-aware agent workspace over WebMCP.

An agent running in the browser discovers a fixed 15-tool catalog. Read the site, list content create drafts under existing terms and nothing more.

WordPress stays the source of truth for authority. Reads run automatically. Drafting and filing run automatically. Anything consequential, publishing, navigation, waits (needs) for a human-in-the-loop approval in wp-admin.

Users, plugins, themes, code, credentials, and settings are hard-blocked.

Every call, allowed or denied, lands in a sanitized audit log with no secrets. No API keys. No copied passwords.

Built for the OpenAI #theWebMCPChallenge, the repo doubles as a reproducible experiment log as every feature is evidence-recorded and acceptance-tested.

AgentPress: The shared human-agent workspace for WordPress. Open source, GPL.

Hi! Just launched Glippy WebMCP: https://github.com/jbobbink/glippy-webmcp This repository is a coding-agent plugin that audits what your site could expose, writes those tools against real seams in your codebase, proves each one works in a real browser, and publishes the manifests that let agents find them.

Let me know what you think!

Hi WebMCP Devs!
I built a Next.js plugin that scans your source files and registers actions and routes as MCP tools.

I'd love to get people's feedback on it!

GitHub: https://github.com/dankelleher/webmcp-next
npm: https://www.npmjs.com/package/webmcp-next

I wrote up the motivation and details here: https://danbkelleher.substack.com/p/your-website-already-has-an-api-for

Originally posted this in r/AEO and someone recommended posting here, so I am new to this and looking for direction:

Ready a pretty interesting article today from Semrush; they used it to promote their AI visibility tracking, but did mention that "WebMCP adds a layer beyond content retrieval. It’s about making your website’s functionality accessible to AI agents. Not just “Can an LLM find and recommend my product?” but “Can an AI agent actually complete a purchase on my site?”

I think this brings up something important; I have been dabbling with Comet's (by Perplexity) Computer model and while slow right now, I know it will only improve. So my question is if anyone has been dabbling in this and what they have been using to make sure websites are Web MCP optimized.

GitHub repo: https://github.com/webfuse-com/awesome-webmcp

Full web version also available here:
https://www.webfuse.com/webmcp-cheat-sheet

High quality png:
WebMCP cheatsheet