Manifest

Turn any webpage into an action manifest for AI agents

API

Developer Tools

Artificial Intelligence

Visit WebsiteSee on Product HuntTwitter ⧉

The requires field encoding dependencies between elements is the interesting part — "select a plan before this button is clickable" is exactly the context accessibility trees drop, and it's where most browser agents burn their retries. Question: how do you handle drift? If the site ships a redesign, does the manifest regenerate per-call (so it's always fresh but you pay latency), or is there caching with some invalidation heuristic? That trade-off decides whether I'd trust it in a scheduled job.

@max_nordstrom that's a genuinely honest answer, most tools would just quietly claim it handles all cases. the disabled/aria-disabled inference makes sense as the pragmatic v1 scope. for the async-JS-validation gap, would something like a lightweight 'confidence' flag on the requires field be feasible - even a rough signal telling the agent 'this dependency was inferred from static DOM, verify before relying on it' vs 'this one's a hard disabled attribute' - or would that just push the complexity onto the caller without really helping?

i spend a lot of time watching agents guess their way around web pages and it is a mess, so this scratches a real itch. the requires field encoding dependencies is the clever bit. who publishes these first though, site owners or agent builders running it on other people's pages? feels like the chicken and egg question

the requires field for element dependencies is genuinely useful, something I've hacked together badly on past projects. excited to try it with an MCP server setup

The dependency tracking between elements is genuinely useful, saved me from manually wiring up plan selection logic in my agent. Curious how it handles shadow DOM and dynamic SPAs though, that's usually where these tools fall apart for me.

Finally a tool that captures the "why" behind clickable elements, not just the selectors. The requires dependency mapping is genuinely useful and saved me a ton of trial and error on a flaky login flow.

honestly the requires field is the part that sold me, most selectors break for me when modals depend on prior actions. gave it a quick spin on a messy form and it nailed the dependency mapping first try.

the requires field for encoding element dependencies is genuinely clever, that's the kind of context aria snapshots miss and usually breaks agents. gonna test it on a gnarly multi-step checkout flow

The action graph idea is really clever, especially encoding those prerequisite relationships between elements. One thing that would help me a lot is a built-in diff or change-detection endpoint, so when a site updates its structure I can quickly see which locators broke and get suggestions for replacements instead of manually hunting through the JSON map. Would save a ton of debugging time in production.

Really cool approach, the requires field for dependencies is a smart solve. One thing that would make this even more useful for us is a built-in way to record and replay the exact sequence of agent actions against a stored map, so we can diff when a site changes and pinpoint exactly which locators broke. Would save a ton of debugging when a flow stops working after a deploy.

the requires field is honestly the standout for me, it captures context i've been missing when agents just blow past dependencies and fail silently. one api call returning resolved locators plus that semantic info is way cleaner than juggling aria snapshots.

The MCP server integration is a nice touch for getting started quickly. One thing that would really help in production is some kind of caching layer for repeated calls to the same URL, since right now it seems like every API request would re-scan the whole page. Even just an optional ETag-style header so we can skip re-mapping when the page structure hasn't changed would save a ton of tokens and latency when agents are looping through tasks on stable sites.

Finally something that gets rid of the brittle XPath mess my scraper has been held together with. The requires field is a nice touch, saved me from another broken dropdown flow.

Really useful for browser agent work, the requires field alone is a nice touch. One thing I'd love is a built-in way to test the generated map against an actual page session, so you can catch mismatches between the JSON output and what the DOM actually looks like before your agent runs.

finally something that gets at the real pain point. the requires field encoding dependencies is genuinely clever, going to wire this into our langchain setup this week and see if it holds up on a few gnarly sites.

the requires field is genuinely useful, been burned by agents clicking submit before the form was complete way too many times. one thing id love to see is a way to mark elements that trigger async loads, like a dropdown that fetches options after you click it. right now my agents try to interact before the data is there

honestly the requires field sounds super useful, would love to see some kind of caching layer for repeat calls on the same URL so agents aren't paying the extraction cost every single time

Tried it on a gnarly multi-step checkout flow and the dependency graph actually caught a hidden "select plan before continue" rule I had been missing. The resolved CSS plus role locators side-by-side saved me a ton of selector soup.

The dependency graph is a really smart touch since most selector tools miss those relationships entirely. One thing I'd love to see is a built-in diff endpoint that compares two Manifest snapshots over time, so when a site silently changes its checkout flow the agent can detect the break before it fails mid-task.