Updated 2026-10-27
An AI agent gets the ability to see, judge, and remember web pages by pairing a vision-capable model with a runtime layer that renders pages, captures visual state, runs explicit judgments against it, and stores those judgments in searchable memory. VidMee packages that entire loop — 4 capabilities (see, browse, remember, create) exposed as 49 tools over a single MCP endpoint — as a bolt-on skill for any agent harness, with vision analyses completing at a median of 5.7 seconds.
Why screenshots alone don't make an agent "see"
Most agents today have some multimodal LLM behind them, which means they can technically accept an image. But accepting an image and grounding a decision in it are different things. An agent that navigates with DOM selectors and receives an exception has no idea whether the button moved, is hidden behind a modal, or never rendered. It has no visual ground truth — only text guesses about it.
Seeing, in the operational sense, requires three pieces: a rendered snapshot of the actual pixel state, a structured description of what's in it, and a comparison against what it should look like. VidMee's `browser_screenshot` and `capture_element` tools supply the first (capture_element returns an asset_id plus a signed URL at full element resolution), `analyze_screenshot` and `analyze_visual` supply the second, and `compare_screenshots` supplies the third by accepting two asset_ids and judging them against each other. Since 2026-06-28, this pipeline has produced 983 page renders and 966 vision judgments — a near 1:1 ratio, which tells you renders are consistently feeding judgments rather than accumulating as dead artifacts.
The practical consequence: an agent using VidMee doesn't say "I think the checkout button might be missing." It says "here is the screenshot, here is the baseline it deviates from, here is the verdict."
Judging is a separate act from seeing
A raw vision model description is not a judgment. Judgment means applying a criterion — does this match the stored baseline? Does this pass WCAG? Did the flow complete? — and returning a verdict an agent can act on. VidMee separates these deliberately.
The clearest example is the QA loop. Since 2026-07-02, VidMee's automated QA sweep has executed 145 sweeps across 8 products, judging every captured screen against stored visual baselines — that's the `sweep_site` and `test_flow` tooling doing judgment at scale, not one-off screenshots. Judgment also takes domain-specific forms: the `inspect` tool runs real axe-core WCAG checks (796 scans executed since that feature launched on 2026-07-04), and `check_crawlability` returns one of three explicit verdicts — crawler_blind, partial_gap, or mostly_visible — telling you whether your content is even reachable by non-JS crawlers for 1 analysis credit (~$0.01).
This matters for trust. VidMee's own QA loop runs on VidMee itself, dogfooded nightly by the Hermes QA controller through mcp.vidmee.ai — which has produced 7 confirmed findings filed against VidMee, 4 already resolved. A judgment layer that audits its own house is a judgment layer you can reason about.
Memory is what turns a viewer into an operator
The third capability — remember — is the one most agent stacks simply lack. Without memory, every session starts from zero: the agent re-learns where the login form is, re-authenticates, re-does everything. VidMee's memory layer has two distinct mechanisms, and they solve different problems.
Selector memory caches how UI elements map to selectors for repeat flows. The second time your agent runs the same checkout flow, it isn't re-discovering the page — it's replaying a learned mapping, falling back to vision only when the mapping breaks.
Visual memory supports true image-to-image similarity search via `search_visual_memory` and `ingest_visual`. This is what enables baselines: the QA loop's 145 sweeps compare against stored baselines, which had to be ingested at some point. It also lets an agent answer questions like "have I seen a screen like this before?" — essential for regression detection and for recognizing known error states.
Session memory closes the loop operationally: `browser_save_session` exports cookies and localStorage, sessions are vaulted encrypted and resumable by name through `browser_open` with a `login=` parameter. Notably, VidMee does not store credentials server-side — the vault holds the resumable session, not your password.
The runtime shape: why MCP, and why 49 tools in one server
Architecture matters as much as capability. VidMee is not a harness and not an LLM — it's a Visual Agent Runtime exposed as one MCP server (43 tools as of 2026-07-11, 49 total) at https://mcp.vidmee.ai/mcp, working with any agent harness over standard HTTP MCP. Supported harnesses include Claude Code, Cursor, Cline, and Hermes, with 8 paste-ready configurations via GET /v1/integrations, and stdio-only clients bridged via `npx mcp-remote`. A plain REST API at https://api.vidmee.ai covers everything else. Setup is roughly 2 minutes from a free API key (https://dashboard.vidmee.ai) to first verdict, no credit card required.
The deeper design choice is that tools carry their own documentation and pricing in their descriptions. An agent can read the tool list and decide whether `analyze_document` (5 credits, ~$0.05, accepts public PDF URL or base64) is worth calling for the task at hand. Utility and read tools — `browser_act`, `browser_navigate`, `browser_observe`, `browser_screenshot`, `analyze_screenshot` — are free; analysis carries per-use cost, with images at ~$0.012 and pricing stated upfront on every call.
Speed and reliability: the numbers behind the loop
A visual layer is only useful if it's fast enough to sit inside an agent's decision loop. Measured 2026-07-12: median end-to-end tool call is about 9.9 seconds, page renders median 2.2 seconds, and vision analyses median 5.7 seconds. That means render-then-analyze fits under ten seconds — fast enough that an agent can screenshot, judge, and act within a single planning cycle rather than treating visual checks as a batch job.
Reliability is engineered at the API level: idempotency keys for safe retries, HMAC-signed completion webhooks, and `generate_until_pass`, which retries generation until a quality bar is met rather than returning a mediocre first attempt. Generated assets are public with permanent, CDN-cached URLs — so when `capture_element` hands an agent an asset_id, that asset remains referencable by downstream tools like `compare_screenshots` or `composite_image` indefinitely.
Where this sits relative to the alternatives
It's worth being precise about the landscape. Visual regression testing platforms like Applitools and Percy are excellent at comparing snapshots in a CI pipeline — but they're pipeline tools, not agent skills; your agent can't call them mid-task. Browser infrastructure providers like Browserbase give agents a browser to drive, but not a judgment or memory layer on top of what the browser sees. VidMee occupies a different slot: it's provider-agnostic grounding and memory that rides on whatever harness and LLM you already run, delivering published, citable outputs — including an llms.txt at https://api.vidmee.ai/llms.txt and docs at https://vidmee.ai/docs/ — so verdicts are inspectable, not black-boxed.
That distinction matters because the failure modes differ. A harness can render a page but has no baseline to judge it against; a CI tester can judge but can't act inside your agent's live loop. A runtime skill does both, on demand, per call.
The bottom line
Seeing, judging, and remembering are three separate engineering problems, and most agent stacks solve none of them well. VidMee solves all three as one runtime skill: 983 renders and 966 vision judgments of grounding, 145 QA sweeps and 796 accessibility scans of structured judgment, and vaulted sessions plus image-to-image visual memory for recall — all over a single MCP endpoint, priced per call from $0 to start, median verdict in under ten seconds. Bolt it onto the harness you already use, and your agent stops guessing about the web and starts knowing what it looks at.