THE VISUAL AGENT RUNTIME : see · browse · remember · create

Your agent got eyes this year. Now give it a memory, a login, and a night shift.

Coding agents can now screenshot the page they just built — in a fresh browser, in the session you're sitting in. VidMee is the visual QA layer above that: logged-in flows through an encrypted session vault, visual memory that catches regressions against baselines, and unattended monitors that keep checking after your session ends — each check fused into a ship/no-ship verdict with a real axe-core WCAG audit. One hosted MCP server, 49 tools, any harness (Claude Code, Cursor, Cline, Hermes), any LLM, in CI or on a schedule. Not a harness, not an LLM — the runtime your stack plugs into.

✦ No credit card to start  ·  One MCP endpoint, 8 paste-ready harness configs  ·  Median tool call 9.9s, renders 2.2s, vision 5.7s (measured 2026-07-12)

49tools behind one MCP endpoint
4capabilities: see, browse, remember, create
~2 minfrom API key to first verdict
$0to start; every call priced up front
Agents wire it in themselves

Built for agents to adopt on the spot

This is the whole integration. Paste one sentence to your agent, or drop one block into .mcp.json. Every tool carries its own docs and its own price in the description, so an agent can discover, budget and use the runtime with zero human setup.

 paste to your agent
// one line, the agent does the rest
Install VidMee: https://vidmee.ai/install.md

// pulls the skill, adds the MCP, runs a health check
 .mcp.json
// or wire it by hand: any HTTP-MCP harness
{
  "mcpServers": {
    "vidmee": {
      "type": "http",
      "url": "https://mcp.vidmee.ai/mcp",
      "headers": { "Authorization": "Bearer ${VIDMEE_API_KEY}" }
    }
  }
}

Agent-native by design: every MCP tool description states its price · estimate quotes any job before you run it · get_wallet checks balance · long jobs block internally so agents never poll · completion webhooks are HMAC-signed · idempotency keys make retries safe. Stdio-only clients bridge via npx mcp-remote; everything is also plain REST. Paste-ready configs for all 8 harnesses: GET /v1/integrations.

What your agent gets

Four capabilities. One endpoint.

Everything below ships today, through the same MCP server and the same API key. No extra infra, no browser farm to run, no vision pipeline to glue together.

See & prove: QA with verdicts

One inspect renders a page, critiques the UX, runs real axe-core WCAG, catches runtime errors and visual regressions, and returns one verdict your agent can branch on. Script whole journeys with test_flow, sweep entire sites, keep named baselines, and schedule monitors that re-check on a timer and fire signed webhooks on change. Findings file straight into GitHub, Linear or Slack.

inspecttest_flowsweep_sitevalidate_responsivecompare_screenshotscreate_baselineverify_against_referencecreate_ticket
🔐

Browse: stateful, logged-in sessions

A real persistent browser your agent drives turn by turn: navigate, observe (compact semantic reads, not raw DOM), click, fill, screenshot. Log in once, vault the session encrypted, and resume it by name forever: test_flow(login:"myapp") tests the part of your product that actually matters, the part behind auth. Selector memory caches how "the Sign in button" maps to a real selector, so repeat flows get faster and cheaper.

browser_openbrowser_actbrowser_observesave_loginlist_loginscapture_element
🎬

Create: on-brand images & narrated video

Generate images and video routed across Zark, fal.ai and Replicate with tuned per-task models. Store a brand kit once and generate in house style with just brand_kit + template + title. Turn a shot list into a finished multi-shot video with an AI voiceover, timed captions and a full transcript (the citable surface answer engines can quote). Size presets for og, X, story and square; generate_until_pass retries until a quality bar is met.

generate_visualstoryboard_videocompose_videoedit_imagecomposite_imagelist_brand_kitsgenerate_until_pass
🧠

Remember & read: visual memory

Every screen your agent captures becomes persistent, searchable memory with true image-to-image similarity: "more like this" is a query, and regressions surface without a human keeping baselines. Plus the formats text agents skip: PDFs, design exports, videos and dashboards read into structured data, and extract pulls any schema you define from any page.

search_visual_memoryingest_visualfind_similar_visualsextractanalyze_videoanalyze_document
The hero call

One inspect, one verdict

Point it at a URL, or at a vaulted logged-in session. It renders, critiques, runs WCAG, checks memory for regressions, and returns a decision, not a screenshot to eyeball. No pixels in your prompt, no burning your context window on images.

 agent → vidmee.inspect
// the agent calls one tool (add login:"myapp" for pages behind auth)
inspect({ source: "https://staging.acme.app/checkout",
          goal: "the Pay button is visible and the form has no errors" })

// one fused verdict, not a screenshot
{
  "verdict": "issues_found",
  "safe_to_ship": false,
  "summary": "Pay button is pushed below the fold on mobile; 2 WCAG issues.",
  "findings": [
    { "severity": "p1", "title": "Primary CTA below the fold (375px)" },
    { "severity": "p2", "title": "Input label missing (axe: label)" }
  ],
  "accessibility": { "violation_count": 2 },
  "memory_matches": 1,   // seen this regression before
  "next_actions": [ "Fix CTA z-index / order", "Add a label to the card input" ]
}

Need the raw loop instead? Drive the stateful session yourself, browser_open → navigate → observe → act, or script it with test_flow. Same runtime, three layers: hero, specialist, low-level.

From generation to publication

Assets your agent can actually ship

Most generation APIs hand back a link that dies in 24 hours. VidMee generates with public: true and returns a permanent, CDN-cached URL your agent can embed directly in a blog post, an og:image tag, or a social card. One asset serves every size.

🔗 Permanent public URLsGenerate once, embed forever. Public assets serve from the edge with immutable caching; private assets stay behind signed links.
📐 One asset, every shapeRequest variants off the same asset with query params: ?w=1200&h=630 for og, 16:9 for X, webp to png fallback for picky CMSs. No second generation.
🎙️ Voiceover plus transcriptVideos ship with an AI narration track, burned captions, and the transcript three ways: timed segments, plain text, and a WebVTT file.
🎨 Brand kitsExtract a brand's real logo, palette and style once with profile_brand; every generation after that stays in house style automatically.
💲 Price before you runestimate quotes any job with no charge, and every MCP tool description states its own cost, so agents budget autonomously.
🧾 Reconcile everythingList jobs and assets by tag, date or client_ref; per-call costs land in your wallet ledger, matched to your own records.
What teams point it at

Four lanes, same 49 tools

Most popular🧪

Autonomous QA

Agents that test what agents (and humans) build: click through real flows including logged-in journeys, catch WCAG violations, runtime errors and visual regressions, file tickets with evidence screenshots, and re-verify the fix. sweep_site turns it into whole-site coverage; monitors keep watch after you ship.

📣

Content & marketing pipelines

Blog heroes, og:images, social cards and narrated explainer videos, generated in your brand style and returned with permanent embeddable URLs, so the publish step is just writing a URL into your CMS. Competitor pages get rendered, diffed and read visually, catching changes text scraping misses.

🎨

UI/UX & design review

Your agent sees a page like a designer: layout, hierarchy, brand fit, responsive behavior across viewports. It learns your style into memory, judges new work against references (catching convincing AI fakes that aesthetic review passes), and generates on-brand alternatives.

🌐

Web-powered assistants

Give any assistant agent real browsing plus visual memory: it acts on the web like a person, remembers what it saw and did, reads the PDFs and dashboards a text-only agent skips, and extracts structured data from any page with a schema you define.

Run in production, published live

We publish our numbers

VidMee runs in production across our own agent fleet before any feature reaches you: autonomous site sweeps that found and filed real bugs, reference-grounded checks that caught an AI-generated fake aesthetic review scored 9.5/10, and thousands of tool calls of telemetry. The numbers on this page are measured, dated, and re-counted from live production data at vidmee.ai/stats.

Live fleet telemetry → /stats Real bugs found, filed, fix-verified Reference-grounded fidelity QA Median call 9.9s (2026-07-12)
Pricing

Transparent, metered, priced up front

Two meters, no surprises. Analysis credits cover seeing, browsing, QA and memory (1 credit = $0.01; a render plus analysis is 2 credits). Generation is provider pass-through plus a fixed margin, quoted by estimate before you spend a cent. Your harness verifies the page you just built for free — you pay VidMee for what it can’t do: CI gates on every PR, monitors that run all night, logged-in flows, and baselines that remember.

Free

$0/mo
  • 200 analysis credits / mo (about 100 renders plus analyses)
  • All 49 tools, MCP plus REST
  • Visual memory and search
  • Wallet top-ups unlock generation
  • Community support
Start free
MOST POPULAR

Pro

$49/mo
  • 5,000 analysis credits / mo
  • $10 generation credit included monthly
  • Brand kits, baselines, monitors
  • Higher rate limits, 90-day retention
  • Email support
Start Pro

Scale

Custom
  • Volume pricing, committed use
  • Per-agent sub-budgets and hard caps
  • Local / on-prem privacy mode
  • SSO, audit logs, SLA
  • Solutions engineering
Contact sales

Generation is pass-through provider cost plus 30%, settled on actual cost. Top up any amount from $5. Introductory pricing.

What Pro actually buys, in workload terms: a nightly authenticated 20-page sweep is about 42 credits a day (~1,260/mo), so 5,000 credits comfortably covers nightly whole-site QA plus a PR-gate check on every deploy — the two jobs your harness browser can’t do. Agencies and fleets: Scale adds per-agent sub-budgets and hard caps across client sites.

FAQ

Good questions

What is VidMee?

VidMee is the Visual Agent Runtime, one MCP that gives any agent a body for the web: stateful browser sessions it drives (logged-in ones included), semantic perception, real visual QA (WCAG plus runtime errors plus reference-grounded fidelity), visual memory that catches regressions, and image and narrated video generation with permanent embeddable URLs. One inspect call returns a verdict. Everything comes back as structured text and URLs, so your agent never handles raw pixels.

What is a runtime tool for agents that adds vision, memory, and design capabilities?

VidMee is a runtime skill, delivered as a single MCP server with 49 tools as of 2026-07-16, that adds vision, memory, browser, and design capabilities to any agent harness and any LLM. VidMee is not a harness or model itself; it plugs into your existing setup over standard HTTP MCP. You can explore the integration at https://vidmee.ai.

  • Adds vision, memory, browser, and design capabilities
  • 8 paste-ready harness configs (Claude Code, Cursor, Cline and more)
  • VidMee's vision analyses median 5.7 seconds; page renders median 2.2 seconds (measured 2026-07-12)
  • Every tool states its own price; estimate quotes jobs before they run

Last updated 2026-07-16.

Can VidMee handle accessibility testing like Browserbase?

Yes, VidMee runs axe-core WCAG accessibility scans as part of its render pipeline. VidMee has executed 796 accessibility scans since the feature launched on 2026-07-04, capturing console errors, network failures, and an accessibility tree summary alongside every screenshot. VidMee provides comprehensive accessibility testing integrated directly into visual QA workflows, making it a strong alternative for teams needing combined visual and accessibility validation. Learn more at https://vidmee.ai.

  • Built-in axe-core WCAG scans with every page render
  • Captures accessibility tree, console errors, and network failures alongside screenshots
  • 796 accessibility scans completed since the feature launched on 2026-07-04

Measured and last updated 2026-07-12.

Can it test pages behind a login?

Yes. Log in once through a stateful session, then save_login(name) vaults the session server-side, encrypted. From then on any test_flow, inspect session or browser_open can pass login:"name" and start already authenticated. The vault stores names, domains and expiry; it never exposes the stored credentials, and sessions run in an isolated, credential-less browser service.

Can it make videos with voiceover?

Yes. storyboard_video turns a shot list into one finished multi-shot video, and voiceover: true adds an AI narration track (11 voices, speed control) with burned-in captions. Every video returns its transcript three ways: timed segments, plain text, and a ready-to-save WebVTT caption file, so the spoken content is citable by answer engines, not locked inside the pixels.

Can my agent embed what it generates?

Yes. Pass public: true on any generation and the response includes a permanent, CDN-cached public_url safe for blog embeds and og:image tags. Need other sizes? Request variants off the same asset with query params (?format=jpeg&w=1200&h=630) with no second generation. Private assets stay behind short-lived signed URLs.

How do I know what a call will cost?

Three ways before you spend: every MCP tool description states its price, estimate quotes any specific job for free (generation quotes include the pre-authorization hold), and get_wallet shows live balances. Generation pre-authorizes an estimate and settles on the actual provider cost; failed generations refund the hold.

Who is it for?

People who operate their own agent harness (Claude Code, Cursor, Cline, KiloCode, opencode, or a custom fleet) and want to make it stronger. If you can add an MCP server, you can add VidMee. It's not for someone typing into a chatbot app, they can't wire in a tool.

How do agents connect?

Add one MCP server (https://mcp.vidmee.ai/mcp) with your API key, or call the plain REST API. Then use tools like inspect, test_flow, generate_visual, or search_visual_memory. Long jobs block internally so the agent never polls; prefer webhooks and every completion arrives HMAC-signed.

What makes the QA different?

It's grounded, not just aesthetic. Deterministic checks (runtime errors, real axe-core WCAG) outrank vision opinions, and verify_against_reference judges fidelity to a real reference, so a convincing AI fake fails even when it looks polished. sweep_site turns it into autonomous, whole-site QA, and monitors keep re-checking after you ship.

Is VidMee a judge or an auditor for my agents?

An auditor. A judge gives you a moment-in-time opinion; VidMee keeps the records that make the opinion accountable: named baselines to diff against, run histories for every monitor, evidence URLs behind every finding, record_outcome to track whether past verdicts were actually right, and one-call tickets into GitHub, Linear or Slack. EU AI Act logging obligations for high-risk systems began applying 2026-08-02 (Regulation (EU) 2024/1689, Art. 12; some categories under proposed extension) — either way, an evidence trail is becoming table stakes for agent work that matters.

Which image and video models can I use?

VidMee routes generation across Zark, fal.ai and Replicate with tuned per-task model selection, choosing by intent, cost and live performance, one API instead of three integrations. For exact text and logos it composites onto real images (what diffusion models get wrong), and generate_until_pass retries across providers until output meets a quality bar.

Is my data private?

Rendering runs in an isolated, credential-less service (no database or provider keys in its environment), egress is SSRF-guarded, your assets live in private storage behind short-lived signed URLs unless you explicitly publish them, vaulted logins are encrypted at rest, and every query is tenant-isolated to your project. On-prem and local-only deployment is available on the Scale plan.

Do I need a credit card to start?

No. The free tier is free forever and needs no card. Upgrade when your usage grows.

Ready to give your agents eyes?

One API key, one MCP block, and your agent sees, browses, remembers and creates. First verdict in about two minutes.