Taskriz
Taskriz and WebMCP
Both give an AI Agent a way to get things done with people and the software they use. They work in opposite directions: WebMCP lets a website hand an Agent in the browser its tools; Taskriz lets your Agent reach a person who isn’t there and get their answer back.
Different jobs
WebMCP
A proposed web standard, drafted by engineers at Microsoft and Google. A web page registers tools — a name, a description, an input schema and a JavaScript function — and an AI Agent in the browser calls them, instead of clicking through the page. The person is on the site, with the Agent beside them.
Taskriz
A service. Your Agent sends a request; Taskriz takes it to the right person — on their phone or computer, now or hours later — and brings their answer back to your Agent as structured data. There’s no website or app for you to build.
On your own website
Taskriz can also live in your website, which is where it comes closest to WebMCP. Paste one snippet and Taskriz runs on your page, in WebAssembly in the visitor’s browser: they say what they need in their own words, Taskriz builds the right form for it, and what they send arrives in your Taskriz inbox from your Agent — that’s Website Requests.
- WebMCP serves the visitor’s own AI Agent. Your site hands that Agent tools, so it can use your site without clicking through its pages.
- Taskriz serves the visitor. Someone with no AI Agent of their own gets a complete request to you — nothing to sign up for or install.
- They can sit side by side. One website can offer WebMCP tools to visitors’ Agents and Taskriz to the visitors themselves.
See it working on the live demo.
What they share
- Built for a human in the loop. WebMCP keeps the person on the page, with the Agent helping; Taskriz brings a person into the Agent’s work when it needs them.
- Structured, not scraped. Both give the Agent a clear schema — WebMCP a tool’s inputs and result, Taskriz the fields a person fills in — rather than leaving it to read screens.
- Close to MCP. WebMCP borrows MCP’s idea of tools; Taskriz offers its own through the Taskriz MCP server.
Side by side
| WebMCP | Taskriz | |
|---|---|---|
| What it is | A proposed browser API, a Draft Community Group Report of the W3C Web Machine Learning Community Group — not yet a W3C Standard | A hosted service, with plugins and an API |
| Which way it works | A website gives an Agent tools to use on that site | An Agent asks a person for something, and gets their answer |
| Who answers | No one is asked: the Agent in the person’s browser calls the site’s tools while they’re on the page | Anyone your Agent sends a request to, from the link they’re sent — no app and no account, straight away or days later |
| Reaching people | Not part of it — the person brings the Agent to the site | An email with the request’s link, opened with a one-time code — no account needed — or your Agent’s QR code or pairing code for people who use Taskriz |
| Telling them a request is waiting | Not part of it | In the Taskriz app, by an email notice, and by text message in Australia and the United States |
| Where it runs | In the website’s open page, in a browser that supports it — Chrome in an origin trial from Chrome 149, and behind a flag for testing | The Taskriz app, in the browser on any phone or computer — nothing to install; or embedded in your own website with one snippet, running in WebAssembly in the visitor’s browser |
| The interface | The website’s own pages; its tools are JavaScript functions with an input schema, registered with document.modelContext.registerTool(). Tools made from HTML forms are being explored, not yet specified | A short Smalltalk program built from iOS-style building blocks — screens, lists, text fields, switches, pickers, date pickers, photo and document pickers, buttons — following world-leading human interface guidelines |
| Answers back to the Agent | A tool’s result, returned to the Agent in the browser that called it | As structured data, matched to the request: through the plugins, a signed webhook, a WebSocket or the events list |
| Connecting your Agent | An Agent in the browser — built into it, in an extension, or the page’s own; it finds a site’s tools by visiting the site | Plugins for Claude Code and ChatGPT, the Taskriz MCP server for any MCP client, and an HTTPS API for any Agent or workflow — wherever it runs |
| People starting things | The person asks the Agent in their browser | Your Agent’s request catalog — actions people start from the Taskriz app |
| Cost | Free to use; you build and run the website and its tools | A Free plan, then paid plans by the requests your Agents send; the people who answer never pay |
Security
WebMCP is a browser API, so it inherits the web’s protections: the page’s own origin, HTTPS, and the browser’s permissions. What a tool may do, and for whom, is designed by whoever builds the site, and the Agent decides when to ask the person first. In Taskriz, a request’s protections come built in.
| WebMCP | Taskriz | |
|---|---|---|
| Who can reach a person | No one is reached; a site’s tools are offered to the page, pages of the same origin and the browser’s Agents — another origin only when the site allows it | Only people your Agent sends a request to, or who paired with it. Someone without an account opens a request with one tap on their first device (a one-time code elsewhere, or when the business asks), and anyone can decline, or stop an Agent reaching them |
| Encryption | The website’s HTTPS — tools are offered only from secure origins | Each request is sealed to the person’s own devices and stored that way, and travels over TLS 1.2 or later |
| Who can read a request | The website, the browser, and the Agent and its AI model | Only the person’s devices — it passes through Taskriz while it’s delivered, and is never stored or logged readable |
| Running the interface | The website’s own pages and JavaScript, in the browser | In a WebAssembly sandbox with no network or file access of its own |
| On your website | Tools are offered to the page’s own origin and the browser’s Agents; another origin only when the site allows it | The embedded request box is a frame from Taskriz that browsers show only on the one website you enter; it sets no cookies and doesn’t measure your visitors |
| Confirming what matters | A site can mark a tool consequential or read-only; the Agent chooses whether to ask the person before using it | The person sees the whole request and answers it themselves |
| Agents and their answers | Each tool checks its inputs and the person’s sign-in to the site | The plugins sign in with OAuth, API Agents with their own credentials, and answers sent to a webhook are signed so your Agent can check they came from Taskriz |
To be plain about Taskriz too: files sent with a request or reply are encrypted on our servers but not sealed to devices, and two-step sign-in is on the Roadmap. Security has the details.
When Taskriz fits
- Your Agent needs someone who isn’t in front of it — an approval, a choice, a date, a photo from the field — and must reach them where they are.
- Visitors to your website should get a complete request to you, whether or not they use an AI Agent.
- Your Agent runs on a server, in a workflow, or in Claude Code or ChatGPT, rather than in someone’s browser.
- You’d rather not build and run a website, notifications, sign-in and delivery to get an answer back.
When WebMCP fits
- You run a website, and want the Agents in your visitors’ browsers to use it reliably, through tools you define, instead of clicking through its pages.
- The person is on your site, working with their Agent.
- You want an open web standard, built into the browser, with your site and its sign-in doing the rest.
Questions
What’s the difference between WebMCP and Taskriz?
WebMCP lets a website give an AI Agent in the person’s browser tools to use on that site, while the person is there. Taskriz is a service: your Agent sends a request, Taskriz takes it to the right person on their phone or computer — now or hours later — and brings their answer back as structured data.
Is WebMCP the same as MCP?
No. They share an idea — tools with a name, a description and an input schema that an AI Agent can call — but MCP connects an Agent to a server, and WebMCP is a proposed browser API that a web page uses to offer its tools to an Agent in the browser. Taskriz works through MCP: the Taskriz MCP server gives any MCP client tools to send people requests and read their answers.
Can WebMCP reach someone who isn’t on the website?
No — it isn’t made to. WebMCP’s tools live in the open web page and are called by an Agent in that browser, with the person there; it doesn’t send anything to anyone else. Reaching another person and bringing their answer back is what Taskriz does.
Can Taskriz run inside my website, like WebMCP?
Yes. Website Requests embeds Taskriz in your website with one snippet; it runs in WebAssembly in the visitor’s browser, and works only on the website you enter. Where WebMCP gives a visitor’s AI Agent tools to use your site, Taskriz takes the visitor’s own words, builds the right form, and sends what they fill in to your Taskriz inbox. A website can offer both.
Which browsers support WebMCP?
WebMCP is a draft from a W3C Community Group, not yet a web standard. Chrome offers it in an origin trial from Chrome 149, and behind a flag for testing. Taskriz needs nothing new from the browser: people answer in the Taskriz app, in the browser on any phone or computer.
About this comparison
WebMCP was checked in November 2026, from the Draft Community Group Report of 11 November 2026 — the WebMCP specification, the WebMCP project on GitHub and Chrome’s WebMCP documentation. WebMCP is the work of the W3C Web Machine Learning Community Group and its contributors, with editors from Microsoft and Google; Taskriz is not affiliated with it. What Taskriz is building next is on the Roadmap.