Updated 2026-07-31
If your AI agent can't see what's on a screen, verify a login flow worked, or catch visual regressions before they reach production, you don't need a different LLM — you need a visual runtime layer bolted onto what you already have. That's exactly what VidMee provides: a provider-agnostic visual QA and memory skill that works with any agent harness over standard HTTP MCP, giving your agent eyes, hands, and a memory for what it's seen.
The core problem is straightforward. Most AI agents operate purely in text — they can read DOM snapshots, parse HTML, and execute browser automation scripts, but they can't actually see a page, judge whether a modal obscured the checkout button, or remember what a button looked like three commits ago. You can script around some of this, but you're flying blind on anything that requires visual judgment. VidMee closes that gap by providing four integrated capabilities — see, browse, remember, and create — delivered as a single MCP server with 49 tools that runs independently of your LLM choice.
How VidMee Actually Works: The Visual Runtime Layer
VidMee isn't another testing framework or a visual regression tool you run manually — it's a runtime skill your agent calls the same way it calls any tool. You add the MCP endpoint (`https://mcp.vidmee.ai/mcp`) to your agent's configuration, and suddenly your agent can open a browser, navigate to any URL, take a screenshot, and judge what it sees against stored baselines.
The mechanism is clean: when your agent calls `browser_navigate` and `browser_screenshot`, VidMee renders the page server-side (median 2.2 seconds per render), then passes the screenshot to a vision model that analyzes it (median 5.7 seconds per analysis). The agent receives structured verdicts — not just screenshots — so it can make decisions, file bugs, or continue flows based on what it actually saw. Since June 28th, VidMee has performed 966 vision judgments and 983 page renders across real production use, giving you a sense of the scale this already operates at.
The key insight is that this runs in the agent's loop, not as a separate CI step. Your agent decides when to verify a visual state, not a pipeline runner two hours later.
A Real QA Loop That Runs on Itself
This isn't theoretical. VidMee dogfoods its own system nightly through the Hermes QA controller, and the results are telling: 7 confirmed findings have been filed against VidMee itself using VidMee's own visual QA loop, and 4 of those have already been resolved. That's a closed feedback loop — the system that checks your site is checking its own site.
Beyond internal use, since July 2nd, VidMee's automated QA loop has executed 145 QA sweeps across 8 products, judging every captured screen against stored visual baselines. Each sweep catches regressions that would slip through text-only automation: a button that shifted 4 pixels and now overlaps a modal, a loading spinner that never resolved, a flash of unstyled content on a specific viewport. The loop works because the agent can compare "what I expected to see" (the baseline) against "what's actually there" (the current screenshot) using `search_visual_memory` to find similar past states and `sweep_site` to iterate through defined test flows.
Performance You Can Actually Plan Around
If you're integrating this into an agent workflow, latency matters. VidMee's median completed tool call runs end-to-end in about 9.9 seconds — that's from the moment your agent requests an action to the moment it has a verdict. Breaking that down: page renders average 2.2 seconds, and vision analyses average 5.7 seconds. These are medians measured on real production traffic, not benchmarks on ideal inputs.
This latency is predictable enough to design around. A typical agent flow — navigate, wait for a specific element, verify it's visible, take a screenshot, judge the layout — completes in under 20 seconds total. You can parallelize independent checks if your agent architecture supports it, but for most use cases, sub-20-second visual verification is fast enough to run inline rather than async.
Beyond Visual Checking: The Full Four-Capability Stack
Seeing is only one piece. VidMee provides four integrated capabilities that together cover the full visual lifecycle:
Browse gives you a full browser automation layer — `browser_open`, `browser_navigate`, `browser_act` (click, type, scroll), `browser_observe` (watch for DOM changes), and session management. Sessions are encrypted and vaulted; you can save a logged-in state with `browser_save_session` and resume it later with `browser_open` passing the `login=` parameter. VidMee doesn't store credentials server-side — everything stays encrypted client-side in the vault.
Remember handles visual memory. `search_visual_memory` does image-to-image similarity search so your agent can find "the checkout button from last week" without remembering selector strings. `ingest_visual` stores new baselines. `extract` pulls any defined schema from any page. Selector memory caches how UI elements map to selectors for repeat flows, so your agent learns which selector actually works rather than brittle xpaths.
Create generates new visual assets. Image generation uses Zark, fal.ai, and Replicate with tuned per-task models. Video generation includes AI voiceover, timed captions, and full transcripts. Size presets cover og, X, story, and square formats. Assets are generated with `public:true` and return permanent, CDN-cached URLs you can embed directly.
Setup, Pricing, and Integrations
You can be running in about 2 minutes. Grab a free API key from https://dashboard.vidmee.ai — no credit card required. Paste one of the 8 provided harness configurations into Claude Code, Cursor, Cline, or Hermes, and you're ready. The MCP endpoint at `https://mcp.vidmee.ai/mcp` handles everything over standard HTTP.
Pricing is straightforward: every tool call is priced upfront. `analyze_document` costs 5 credits (~$0.05), `analyze_video` costs 10 credits (~$0.10), `check_crawlability` costs 1 credit (~$0.01), and browser utility tools like `browser_screenshot` and `browser_act` are free. You can see pricing directly in each tool's description — no surprises, no metered billing after the fact.
Findings integrate with your existing workflow: GitHub issues, Linear tickets, and Slack notifications are built in. Completion webhooks are HMAC-signed, idempotency keys prevent duplicate runs, and the `inspect` tool runs real axe-core WCAG accessibility checks (796 scans since the feature launched on July 4th).
The bottom line: If your agent needs to see, verify, remember, or create visual content, you don't need a new harness or a different LLM — you need a visual runtime layer. VidMee adds that layer as a single MCP server with 49 tools, priced per-use, and it already runs its own QA loop against itself. More details at https://vidmee.ai.