Tools

Pomerado Turns Websites into MCP Tools for AI Agents

Pomerado aims to wrap websites that lack APIs into callable MCP interfaces within minutes. This article examines how it works, how developers connect to it, and the risks of running it in production.

Font size

YC F26 startup Pomerado wants to turn any website into a deterministic, self-healing MCP interface in just a few minutes. Its focus is not making agents smarter, but reducing the cost and failure rate of browser automation.

Agents Are Not Failing at Reasoning

Many AI agent projects assume one of two things: the target system exposes an API, or an agent can reliably operate its browser through computer use.

Real-world businesses rarely work that way.

An airline's flight-change process may span a legacy customer service system, internal rules, and several layers of forms. Banking sites depend on login state, device verification, and permission tiers. Insurance claims involve uploading documents, supplying missing materials, and waiting for manual review. Some legacy portals do not even have developer documentation.

In these environments, an agent usually fails not because it does not know what to do next, but because it cannot complete that next step reliably. A page element has moved, a button is covered, a CAPTCHA appears, a session expires, or a click sends the workflow down an unexpected branch.

An LLM re-observes and re-decides at every step, paying the costs of tokens, latency, and tool calls each time. Business automation needs a narrower abstraction: take a booking number, identity document, and reason for the change as inputs, and return a verifiable result, rather than letting an agent freely explore the entire site.

The Pomerado team wraps websites into deterministic, self-healing APIs and exposes them to agents through MCP. That is where it targets the gap.

The Hidden Costs of Browser Automation

Browser automation is not useless. It works well for low-frequency, exploratory tasks on sites that change rarely. The problem is that treating a browser as a production-grade API requires accounting for three additional costs.

The first is page interpretation.

An agent receives screenshots or a DOM, not business fields. It has to recognize the departure city, flight date, passenger name, and submit button. Similar button labels, fields without stable selectors, and pop-ups that cover content all increase the chance of mistakes. Every fresh pass over the page also means more visual tokens, context, and model calls.

The second is action execution.

Real clicks are slower than calling a JSON API. A click may be followed by page loading, animation delays, network requests, and confirmation that the state changed. Scrolling, opening dropdowns, and switching iframes can each introduce a retry point. The agent must also infer whether an action succeeded from page feedback instead of receiving an explicit success response.

The third is failure recovery.

This is the cost most likely to be hidden in a demo. After a network timeout, should the agent retry or take another path? When a CAPTCHA appears, should it wait or hand off to a person? After a login expires, are the page's element locators still valid? Strong models can sometimes work around these problems, but every workaround adds model calls and risks duplicate order submissions, duplicate charges, or lost form data.

Browser automation being slow, expensive, and unstable is therefore not primarily a model-capability problem. It is an interface-granularity problem: the agent is forced to understand the page when the business actually needs a stable contract.

How Pomerado Wraps a Website as an MCP Interface

According to the Launch HN summary, Pomerado's product works by converting a website into deterministic, self-healing APIs within minutes and exposing them to agents through MCP. The onboarding is described as fully self-serve, with no need for engineers to label every page by hand.

This differs from traditional RPA script recording, which often hard-codes selectors that break whenever a site is redesigned. Pomerado emphasizes self-healing, with the goal of locating and restoring critical workflows after page structures change rather than permanently maintaining a brittle set of scripts.

For an agent, change happens at the interface boundary.

Ideally, the upstream layer sees a business tool rather than browser operations:

{
  "name": "search_available_flights",
  "description": "查询指定日期和航线下的可售航班",
  "inputSchema": {
    "type": "object",
    "properties": {
      "origin": {"type": "string"},
      "destination": {"type": "string"},
      "departure_date": {"type": "string", "format": "date"}
    },
    "required": ["origin", "destination", "departure_date"]
  }
}

This is the protocol shape of an MCP tool description, not publicly released invocation code from Pomerado. It illustrates the core product design: narrow ambiguous web steps into explicit inputs, structured outputs, and states that can be evaluated.

The model no longer has to observe the page and decide where to click on every run. It calls an interface and waits for a result. When a site changes locally, the wrapper handles the recovery logic.

Two terms need to be distinguished here.

“Deterministic” does not mean that natural language model reasoning will always be perfectly stable. It means that the same task should produce consistent, inspectable business behavior. For example, querying the same order number should not produce random results. When no result exists, the interface should explicitly return not_found instead of treating a blank page as success.

“Self-healing” does not mean that every redesign can be repaired automatically. A more reasonable interpretation is that the system can relocate elements and continue when local DOM, layout, or flow branches change. Whether it can cover complex business processes depends on the actual implementation and regression testing.

Self-Serve Onboarding Remains the Big Unknown

Fully self-serve onboarding is both Pomerado's most attractive feature and its hardest claim to verify.

If onboarding still requires engineers to analyze each page, label fields, handle logins, and continuously repair scripts, the product solves only part of the development work and leaves the heaviest operational burden of browser automation untouched. Converting a site in minutes implies that the system can identify page types, key fields, business actions, and result states on its own.

The claim that it works with “any website” needs to be broken down and tested.

Site redesigns are the most obvious variable. An airline may change its date picker, a bank may rebuild its login flow, and an e-commerce site may insert a risk-control page before checkout. The wrapper needs to distinguish changes that are merely layout noise from those that signal a shift in business rules.

CAPTCHAs and anti-automation controls are the second variable. Pomerado should not be understood as a way to bypass security measures. The reasonable approach is to use APIs, accounts, or enterprise authorizations that a site permits, pausing and resuming when manual verification is required rather than circumventing risk controls on a user's behalf.

Login state and permission boundaries are the third variable. Whose account does the agent use? How is it renewed after expiration? Could a read-only query accidentally trigger a payment, refund, or information change? Every tool should define its permissions, operational scope, and idempotency.

The most important validation is workflow regression testing. A page that opens only proves that extraction worked; it does not show that the business flow is usable. The system needs to check continuously:

  • Whether query results match those on the original site;
  • Whether exception branches return clear errors;
  • Whether workflows recover after a site redesign;
  • Whether repeated calls create duplicate orders or charges;
  • Whether the system stops safely when logins expire, CAPTCHAs appear, or rate limits are reached;
  • Whether critical steps produce auditable logs.

For enterprise use cases, 100% automation is not the only goal. When payments, medical records, or government filings are involved, a checkpoint that allows human confirmation is often more reliable than pursuing end-to-end unattended operation.

The Bigger Picture

MCP's value is changing. In early discussions, it looked more like a universal socket for tool calls: search, files, databases, and code execution could be connected and used immediately. Its more valuable role now is connecting closed business systems that lack APIs, have sparse documentation, and are slow to maintain. Pomerado's focus on airlines, banks, insurance, and legacy portals suggests the market is shifting from asking which tools an agent can call to asking whether an agent can complete a real business transaction.

MCP is unlikely to replace direct website access. It is more likely to create a two-layer architecture: stable tools for agents on top, with page handling, authentication, and recovery underneath. Deterministic interfaces are especially suitable for frequent, verifiable workflows, while open-ended computer use remains useful for one-off exploration.

The difference here is not simply that yet another MCP server exists. The attempt is to move the cost of browser adaptation from every agent run into a single maintainable wrapper. But “minutes” and “any website” remain product claims, not guarantees of production reliability. The real test is not whether a demo can book a flight, but whether the core path still completes correctly after a redesign, an expired login, and a repeated submission. Pomerado's ceiling will ultimately depend on how it stops when something fails, not only on how quickly it succeeds.

Source: https://news.ycombinator.com/item?id=50455811