AgentRep

WebMCP makes websites agent-ready. AgentRep helps AI agents discover and compose those capabilities across the web to accomplish a user's goal.

Comment

Inspiration

WebMCP makes individual websites agent-ready by letting them expose structured tools directly to AI agents.

But that creates another problem: if thousands of websites expose capabilities, how does an agent know which websites can actually help accomplish a user's goal?

We built AgentRep — a capability discovery layer for the agentic web.

WebMCP makes websites agent-ready. AgentRep makes their capabilities discoverable and composable.

What it does

A user gives ChatGPT a goal rather than a sequence of websites to visit.

AgentRep helps discover the WebMCP capabilities needed for that goal. ChatGPT reasons over those capabilities, composes a plan, invokes provider tools, adapts when requirements change, and asks for human approval before irreversible actions.

Our birthday-planning demo is deliberately a proof of this broader model.

The demo begins with three independent WebMCP providers:

  • PartyHub — venues
  • FoodHub — catering
  • CakeHub — cakes

ChatGPT uses AgentRep to discover and compose these capabilities into one plan.

Then the requirements change.

The cake preference changes. The guest count increases from 20 to 25, making the existing cake invalid. Instead of restarting a fixed workflow, the agent preserves what still works and recomposes the invalid parts.

Then something more important happens:

A fourth WebMCP provider becomes available while the task is already underway.

PokémonPartyHub exposes a new entertainment capability. The user simply asks to add Pokémon entertainment — without naming the provider.

AgentRep discovers the newly available capability, and ChatGPT incorporates it into the existing plan.

The final composition spans four independent websites and remains within the updated ₹20,000 budget.

Before booking, AgentRep creates a single human approval checkpoint for the exact plan and total.

Only after approval does ChatGPT invoke the transactional WebMCP tools.

The demo ends with four real booking confirmations across four independent providers from one user goal.

How we built it

AgentRep and each provider are independent web origins exposing tools through WebMCP.

The implementation uses document.modelContext.registerTool(...) and @agentrep/webmcp to register structured tools with descriptions, JSON schemas, and execution handlers.

Provider origins expose domain-specific capabilities for search, details, availability, pricing and transactional actions.

AgentRep provides capability discovery, shared plan state and the human-approval boundary, while ChatGPT remains responsible for reasoning and composition.

Cross-origin provider tools are exposed in one agent-visible workspace using WebMCP tool permissions.

For irreversible actions, approval is bound to the exact plan using plan hashes, state versions and single-use approval tokens, preventing stale approvals from executing changed plans.

The dynamic discovery proof

For the demo, provider indexing is intentionally simulated so the discovery transition is deterministic and easy to reproduce.

The important distinction is that PokémonPartyHub and its WebMCP tools are real.

Before indexing, its entertainment capability is unavailable to AgentRep.

After indexing, the same running task can discover and use that new capability without the user providing the website URL.

This demonstrates the larger direction for AgentRep: an open capability registry where WebMCP-enabled websites publish machine-readable capabilities and agents discover providers based on what they need to accomplish.

Challenges we ran into

The hardest problem wasn't making another AI planner.

It was maintaining a clean boundary between discovery, reasoning and execution.

AgentRep should not secretly become the reasoning agent. ChatGPT reasons and composes; AgentRep discovers capabilities and maintains shared state; independent websites own and execute their WebMCP tools.

We also had to solve cross-origin tool exposure, changing constraints without restarting the workflow, dynamic capability arrival, and safe human approval for transactional actions.

What we learned

WebMCP becomes especially interesting when you stop thinking about one agent using one website.

If many independent websites expose capabilities, agents need a way to discover and compose those capabilities around user intent.

Our birthday example is only the proof.

The birthday is not the product. Capability discovery is.

What's next

Today, AgentRep demonstrates discovery across registered WebMCP providers, including a new provider becoming discoverable during an active task.

The larger vision is an open capability registry for the agentic web — where websites publish what they can do and agents discover capabilities based on goals instead of starting with URLs.

Discover → Compose → Execute.

Built With

Share this project:

Updates

Submission history