Eyelet WebMCP Probe

• 

  Live Agent Invocation

Inspiration

Eyelet WebMCP Probe started from one question: if a webpage already knows what it can do, why should an agent have to guess where to click?

The goal was to prove the smallest useful human-agent handoff I could make: one visible note, one declared capability, and one result both the human and the agent can understand.

What it does

Eyelet WebMCP Probe lets a person pin a short note through an ordinary webpage form. An agent can discover the page's structured remember_note WebMCP tool and pin the same kind of note directly.

Both paths update the same visible card, and agent-made changes are clearly labeled Pinned by Agent.

The result is deliberately simple: the agent acts through a capability the page explicitly declares, while the person sees exactly what changed and retains normal control.

How I built it

The project is a dependency-free static site built with HTML, CSS, and JavaScript.

It registers one WebMCP tool with:

document.modelContext.registerTool(...)

The tool is:

• remember_note
• one required string input
• limited to 180 characters
• executed through the same application function used by the human form
• reflected immediately in the visible UI

There is no backend, account, database, analytics, cookie, upload, or private system connection.

The project is deployed publicly with GitHub Pages and the repository includes an MIT license.

Challenges I ran into

The biggest challenge was proving the real agent path rather than stopping at code that merely looked correct, buy trial and error.

Ordinary Chrome on my development machine did not expose the WebMCP capability I needed for the final proof. The working validation therefore had to happen against the public HTTPS deployment through ChatGPT's WebMCP-capable in-app browser.

That final test proved the important part: ChatGPT discovered remember_note, invoked it, and the live page visibly changed to show the result as Pinned by Agent.

Accomplishments that I'm proud of

This project now has a complete end-to-end proof:

• a public HTTPS application
• a public repository
• an MIT license
• a WebMCP tool that can be discovered by an agent
• successful live agent invocation
• a visible result a human can immediately verify
• a normal human interaction path that remains available alongside the agent path

What I learned

The smallest credible WebMCP experience does not need to be a large agent platform.

A useful pattern can be much smaller:

Declare one useful capability, let an agent invoke it directly, make the result visible to the human, and preserve ordinary human control.

That creates a cleaner relationship between webpages and agents than forcing the agent to infer controls or imitate a person.

What's next for Eyelet WebMCP Probe

The probe is intentionally small, but the pattern can expand to other bounded webpage actions where explicit, typed capabilities are safer and clearer than UI guessing.

For this Challenge, though, the focus is the proof itself: one declared capability, one successful agent invocation, and one visible human-verifiable result.

Built With

• chatgpt
• css
• github
• html
• javascript
• pages
• webmcp