webEmbedding
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@webEmbedding clone the landing page at https://mozilla.org"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
webEmbedding
webEmbedding clones any web page from its URL for AI coding agents. Give Claude Code, Codex, Cursor, or any MCP client a URL and it returns a verified clone: the original embed when the page allows it, otherwise a self-contained offline HTML snapshot (inlined CSS, shadow DOM, localized fonts and images) or a bounded rebuild, scored against desktop, tablet, and mobile screenshots of the live page.
Add it to your agent in one line:
claude mcp add web-embedding -- npx -y web-embedding@latest mcp # Claude Code
codex mcp add web-embedding -- npx -y web-embedding@latest mcp # Codex CLIThen ask: "Clone https://example.com into ./clone and tell me the fidelity score." (Machine-readable summary for LLMs: llms.txt.)
webEmbedding is a source-first website cloning engine: it captures live pages with Playwright, replays network evidence from HAR artifacts, rebuilds only when direct reuse is blocked, and self-verifies the result.
It ships as a Skill + MCP server. Instead of asking a model to "clone this site" from a screenshot, it inspects the URL, chooses a reuse or rebuild route, captures DOM/runtime HTML/styles/assets/network traces, generates bounded frontend reconstruction artifacts, and checks the output with visual, DOM, computed-style, interaction, and responsive-breakpoint verification.

GitHub listing, social preview, and launch-copy recommendations are in docs/github-listing.md.
Current Status
The current pipeline is strongest for static and semi-static web pages:
company, brand, marketing, and documentation pages
public landing pages
iframe-blocked pages that need capture-based reconstruction
responsive page snapshots across desktop, tablet, and mobile
It is not a full backend or app-logic clone engine. Login-only screens, app-first or native-app-required services, captcha-heavy sites, maps, games, canvas/WebGL-heavy pages, real-time feeds, payments, booking flows, and private server behavior still need separate handling.
Operationally, the repo is now a production-candidate clone engine for URL-based capture and bounded reconstruction: jobs can be queued, network evidence can be replay-audited from HAR artifacts, authenticated dashboard runs can be driven from user-owned browser state, and local gates verify the route corpus, score checks, package contents, and CI wiring. The remaining hard boundary is server-side product behavior, not front-end evidence capture and reconstruction.
Related MCP server: WebClone MCP Server
Measured Checkpoints
Local benchmark runs from this repo (scripts/check_clone_quality_bench.py, mobile + tablet breakpoints, 2026-10-28):
URL | Path | Score | Wall time |
| runtime snapshot | root | ~34 s |
| runtime snapshot | root | ~40 s |
| runtime snapshot | root | ~43 s (was ~160 s) |
| runtime snapshot | root | ~226 s (was ~1011 s, failed at |
| exact reuse | ready | — |
These are generated by the local self-verify pipeline, not manually assigned ratings. Earlier bounded-rebuild previews embedded the reference screenshot, which inflated their visual score; the runtime snapshot renders real DOM and CSS, and every row above was also checked by side-by-side screenshot review. Known gap: layouts that page scripts compute for viewports other than the captured one (for example masonry footers) can still drift at tablet width.
The reproducible commands and score thresholds are tracked in docs/benchmark-evidence.json.
Production readiness gates are tracked in docs/production-pipeline-gates.json.
Core Features
Source-first routing:
direct iframe or embed reuse when it is safe and frameable
original preview, export, remix, or source routes when available
bounded rebuild only when exact reuse is unavailable
Live browser capture:
DOM snapshot
runtime HTML
full-page screenshot
computed style summaries
CSS analysis
asset inventory
HAR-like network metadata
interaction states and replay traces
storage state export for session-aware flows
Blocked-site rebuild:
handles
X-Frame-Optionsand CSP-blocked pages by rebuilding from captured evidencegenerates reusable frontend reconstruction artifacts from captured page structure
preserves custom tags, shadow-root host structure, and semantic document structure where captured
Evidence limitation reporting:
separates directly captured artifacts from inferred or missing evidence in reproduction results and prompts
marks app-gated, auth-gated, and native-app-led surfaces as bounded evidence, with recommendations for user screenshots or authenticated session capture
Operational failure classification:
reports typed pipeline action codes such as
network-replay-limited,auth-session-missing,public-app-gate, andcanvas-visual-fallbackexposes HAR/network
replay_readinessbefore treating captured network evidence as replay-grade
Production pipeline helpers:
filesystem-backed async clone job queue with durable JSON records, worker locks, retry scheduling, cancellation, and manifest annotation
deterministic HAR replay engine for standard HAR, near-HAR, and captured
network/manifest.jsonartifactsauthenticated dashboard live corpus runner that accepts user-provided
storage_state_pathoruser_data_diroutside the repo
Self-verification:
screenshot similarity
DOM snapshot similarity
computed-style similarity
hover/focus/click interaction state parity
interaction trace parity
desktop/mobile/tablet breakpoint reports
Responsive benchmark support:
primary desktop viewport:
1440x1200tablet profile:
768x1024mobile profile:
390x844
Repair loop:
bounded self-repair can run when the first scaffold misses the readiness threshold
Install
Requirements
Node.js 18 or newer
Python 3.9 or newer
Chrome or Chromium available locally for Playwright runtime capture
The package uses playwright-core; it does not download a browser by itself.
Installing this project adds the source-first-clone plugin bundle, the exact-clone-intake skill, and the MCP server that exposes the URL inspection, capture, rebuild, and verification tools.
Install From npm
npm install -g web-embedding
web-embedding install
web-embedding doctorClone a public URL after installing:
web-embedding clone \
--url https://developer.mozilla.org/en-US/ \
--output-dir ./.tmp/mdn-clone \
--wait-seconds 2 \
--timeout-seconds 35 \
--breakpoints mobile tabletIf you already have an older local plugin installed, overwrite it with:
web-embedding install --force
web-embedding doctorYou can also run the installer without a global install:
npx web-embedding installUse As An MCP Server
For MCP clients that can launch npm stdio servers:
{
"mcpServers": {
"source-first-clone": {
"command": "npx",
"args": ["-y", "web-embedding@latest", "mcp"]
}
}
}For local smoke testing:
npx web-embedding@latest mcpThe MCP Registry identity is io.github.jongko54/web-embedding; server.json and package.json#mcpName are kept in sync for registry ownership verification.
Hosted Apps SDK Intake Endpoint
The public remote MCP intake endpoint for Apps SDK Developer Mode is:
https://webembedding-jongkos-mcp.vercel.app/mcpIt exposes low-risk source-first routing tools such as URL inspection, embed candidate discovery, clone-mode classification, and embed snippet generation. Full browser capture, HAR replay, queues, bounded rebuilds, and one-pass clone execution remain local-first through the stdio MCP package.
Apps SDK review pages are hosted alongside the endpoint:
https://webembedding-jongkos-mcp.vercel.app/privacy.html,
https://webembedding-jongkos-mcp.vercel.app/terms.html, and
https://webembedding-jongkos-mcp.vercel.app/submission.html.
Sandboxing And Approvals
webEmbedding has two different execution boundaries:
Hosted Apps SDK intake: read-only URL routing and classification only. It accepts absolute
httpandhttpsURLs, does not run Playwright, does not read local files, does not use browser profiles or storage state, and does not persist capture artifacts.Local stdio MCP and CLI: full capture, HAR replay, queues, rebuild scaffolds, and self-verify run on the user's machine under the user's local agent and filesystem permissions. Output is written only to caller-provided paths such as
output_dirorqueue_root.Authenticated capture: session-aware runs require the caller to intentionally provide a
storage_state_pathoruser_data_dir. webEmbedding does not collect credentials, perform login bypasses, or treat a public login shell as private app evidence.Access-controlled surfaces: paywalls, captcha flows, private dashboards, payment/checkout/account/admin flows, and native-app-led screens should be blocked, marked
needs_session, or sent to manual review unless the user has explicit authorization and supplies the needed evidence.
Local URL entrypoints reject non-HTTP schemes such as file:// so an agent cannot use clone/capture tools as a local file reader. Telemetry is disabled by default and, when enabled, excludes target URLs, local paths, captured HTML, screenshots, storage state, environment variables, API keys, and command output.
Agent Marketplaces
This repository includes marketplace metadata for the two local agent surfaces:
Codex:
.agents/plugins/marketplace.jsonpoints to./bundle/source-first-clone.Claude Code:
.claude-plugin/marketplace.jsonpoints to the same bundle and the bundle includes.claude-plugin/plugin.json.
Claude Code users can add the marketplace from GitHub with:
/plugin marketplace add jongko54/webEmbedding
/plugin install source-first-clone@webembeddingAI auto-selection expectations and golden prompts live in docs/ai-distribution.md and evals/ai-selection/webembedding-golden-prompts.json.
Install From Release
curl -fsSL https://github.com/jongko54/webEmbedding/releases/latest/download/install.sh | bashInstall From This Checkout
git clone https://github.com/jongko54/webEmbedding.git
cd webEmbedding
npm install
node ./bin/web-embedding.mjs install
node ./bin/web-embedding.mjs doctorInstall Into A Temporary Home
Useful for testing without touching your real agent home:
python3 python/web_embedding/installer.py install --target-home ./.tmp/home
python3 python/web_embedding/installer.py doctor --target-home ./.tmp/home
python3 python/web_embedding/installer.py uninstall --target-home ./.tmp/homeOpt-in Telemetry
Telemetry is disabled by default. On an interactive first install, web-embedding install asks once and defaults to No. Non-interactive installs such as CI and curl | bash do not prompt. If you opt in, web-embedding sends a small anonymous command-completion event to a JSON POST endpoint you control. It does not send target URLs, local paths, captured HTML, screenshots, storage state, environment variables, API keys, or command output.
Enable it during install:
web-embedding install --telemetry --telemetry-endpoint https://your-collector.example/eventsOr manage it later:
web-embedding telemetry enable --endpoint https://your-collector.example/events
web-embedding telemetry status
web-embedding telemetry disable
web-embedding telemetry reset-idEach event contains an anonymous install id, package version, command name, success/failure status, OS/runtime basics, and coarse option flags such as breakpoint_count or install_source.
Environment controls:
WEB_EMBEDDING_TELEMETRY=1
WEB_EMBEDDING_NO_TELEMETRY=1
WEB_EMBEDDING_TELEMETRY_PROMPT=0
WEB_EMBEDDING_TELEMETRY_ENDPOINT=https://your-collector.example/events
WEB_EMBEDDING_TELEMETRY_LOG=./telemetry.jsonlRun a local/self-hosted JSONL collector:
npm run telemetry:collector -- --host 127.0.0.1 --port 8765 --out ./telemetry.jsonl
WEB_EMBEDDING_TELEMETRY=1 \
WEB_EMBEDDING_TELEMETRY_ENDPOINT=http://127.0.0.1:8765/events \
web-embedding doctorSummarize collected usage:
npm run telemetry:summarize -- ./telemetry.jsonlThe summary includes install and clone executions, total command executions, unique anonymous install IDs, command counts, and version counts. See docs/telemetry.md for collector and analyzer details.
Quick Start
Inspect a URL and get route hints:
node ./bin/web-embedding.mjs inspect \
--url https://developer.mozilla.org/en-US/Run a safe preflight audit before capture or clone:
node ./bin/web-embedding.mjs audit \
--url https://developer.mozilla.org/en-US/The audit reports whether the reference is ready for exact/embed reuse, needs local capture, needs an authenticated session, requires manual review, or should be blocked before any browser capture or filesystem output runs.
Run the full clone workflow:
node ./bin/web-embedding.mjs clone \
--url https://developer.mozilla.org/en-US/ \
--output-dir ./.tmp/mdn-clone \
--wait-seconds 2 \
--timeout-seconds 35 \
--breakpoints mobile tabletRun a lightweight quality benchmark:
python3 scripts/check_clone_quality_bench.py \
https://developer.mozilla.org/en-US/ \
--output-root ./.tmp/clone-quality-bench \
--wait-seconds 1 \
--timeout-seconds 35 \
--breakpoints mobile tabletThe benchmark prints compact rows for root, visual, and breakpoint scores. The full artifacts are written under the output directory.
CLI Commands
node ./bin/web-embedding.mjs capabilities
node ./bin/web-embedding.mjs install
node ./bin/web-embedding.mjs doctor
node ./bin/web-embedding.mjs uninstall
node ./bin/web-embedding.mjs paths
node ./bin/web-embedding.mjs telemetry statusnode ./bin/web-embedding.mjs inspect --url https://www.mozilla.org/node ./bin/web-embedding.mjs audit --url https://www.mozilla.org/node ./bin/web-embedding.mjs capture \
--url https://www.mozilla.org/ \
--output-dir ./.tmp/capture-mozilla \
--breakpoints mobile tabletnode ./bin/web-embedding.mjs reproduce \
--url https://www.mozilla.org/ \
--output-dir ./.tmp/reproduce-mozilla \
--breakpoints mobile tabletnode ./bin/web-embedding.mjs clone \
--url https://www.mozilla.org/ \
--output-dir ./.tmp/clone-mozilla \
--breakpoints mobile tabletnode ./bin/web-embedding.mjs verify \
--reference-bundle ./.tmp/reference/capture.json \
--candidate-bundle ./.tmp/candidate/capture.jsonOutput Artifacts
A clone run can produce:
capture.jsonpipeline-run-manifest.jsondom/snapshot.jsondom/runtime.htmlstyles/computed-summary.jsonstyles/css-analysis.jsonnetwork/manifest.jsonnetwork/har.jsonnetwork/har-like.jsonnetwork/replay-report.jsonassets/inventory.jsoninteractions/states.jsoninteractions/trace.jsonscreenshots/runtime.pngsession/storage-state.jsonreproduction/plan.jsonreproduction/evidence-limitations.jsonreproduction/rebuild-prompt.txtreproduction/rebuild/starter.htmlreproduction/rebuild/starter.cssreproduction/rebuild/starter.tsxreproduction/rebuild/next-app/reproduction/self-verify/summary.jsonreproduction/self-verify/renderers/*/verification.jsonreproduction/self-verify/renderers/*/visual-qa.jsonreproduction/self-verify/renderers/*/breakpoints/*-verification.json
Quality Benchmark
Run the default small benchmark:
npm run check:clone-bench:localRun the universal route regression corpus and expectations gate:
npm run check:benchmark-routes:localRun a lightweight clone score gate:
npm run check:clone-score-gate:localValidate the committed benchmark evidence manifest:
npm run check:benchmark-evidence:localValidate production pipeline gates:
npm run check:production-readiness:localRun the operational smokes individually:
npm run check:job-queue:local
npm run check:har-replay:local
npm run check:authenticated-corpus:localClassify failure/action codes from a route report:
npm run classify:pipeline-failures -- --report ./.tmp/universal-route-benchmark/universal-route-report.jsonFind low-scoring persisted benchmark artifacts:
npm run summarize:benchmark-scores -- --root ./.tmp --min-score 60 --max-score 70Run specific URLs:
python3 scripts/check_clone_quality_bench.py \
https://www.example.com \
https://www.mozilla.org/ \
--no-breakpointsRun a responsive benchmark:
python3 scripts/check_clone_quality_bench.py \
https://developer.mozilla.org/en-US/ \
--breakpoints mobile tabletDevelopment Checks
python3 -m py_compile \
bundle/source-first-clone/mcp/source_first_clone/*.py \
scripts/check_integration_smoke.py \
scripts/check_clone_quality_bench.pynpm run check:integration:localgit diff --checkRepo Layout
bundle/source-first-cloneInstalled plugin bundle, MCP server, and exact-clone intake skill.bundle/source-first-clone/mcp/source_first_cloneCapture, planning, rebuild, repair, and verification engine.bin/web-embedding.mjsNode CLI wrapper.python/web_embedding/installer.pyShared installer and command dispatcher.scripts/check_clone_quality_bench.pyURL clone quality benchmark helper.scripts/benchmark_routes.pyUniversal route/capture-depth regression benchmark helper.scripts/check_benchmark_report.pyBenchmark expectation validator for exact, minimum, and contains-style checks.scripts/check_benchmark_evidence.pyBenchmark evidence manifest validator.scripts/check_job_queue_smoke.pyFilesystem async clone job queue smoke test.scripts/check_har_replay_smoke.pyDeterministic HAR replay engine smoke test.scripts/benchmark_authenticated_corpus.pyUser-provided authenticated dashboard corpus runner.scripts/summarize_benchmark_scores.pyUtility for finding low or high scoring persisted benchmark artifacts under an output root.scripts/classify_pipeline_failures.pyOperational failure/action taxonomy summarizer for reports and capture artifacts.scripts/check_production_readiness.pyProduction readiness gate validator for corpus, failure taxonomy, CI wiring, and policy docs.scripts/check_integration_smoke.pyRelease, install, and URL-only clone smoke test.scripts/release_bundle.pyRelease artifact builder.docs/Architecture notes and universal benchmark documentation.
Positioning
The strongest claim for this project is:
A source-first website cloning engine that combines Playwright capture, HAR replay, MCP tools, and self-verification to rebuild iframe-blocked public pages with reproducible visual, DOM, style, interaction, and responsive scores.
Avoid treating the output as a legal or ownership bypass. The engine can reconstruct public page structure, but permission, licensing, and acceptable use still matter.
FAQ
How can an AI coding agent clone a website from a URL?
Install the MCP server (npx -y web-embedding@latest mcp) and ask the agent to clone the URL. The agent calls clone_reference_url, which inspects the page, captures it in a real Chromium, picks reuse or rebuild, and returns the clone entrypoint with fidelity scores.
What does the clone look like on disk?
For pages that block iframes, snapshot/index.html plus snapshot/assets/ is a self-contained copy of the rendered page: stylesheets inlined from source (including CSS-in-JS and adoptedStyleSheets), open shadow roots as declarative shadow DOM, canvas pixels, form state, and localized images, fonts, and SVG sprites. Serve it over HTTP (python3 -m http.server); file:// blocks external SVG <use> references.
How is this different from SingleFile, screenshot-to-code, or open-lovable? SingleFile saves a page from a browser extension or CLI; webEmbedding uses the same class of DOM serialization but runs as an MCP tool, decides between embed reuse, snapshot, and rebuild, and verifies the result at three breakpoints. Screenshot-to-code and open-lovable generate new code from an image or scrape with an LLM; webEmbedding starts from the live DOM and CSS, so text, fonts, and layout come from the source instead of being re-imagined.
What can't it clone? Server behavior (logins, payments, search, real-time data), captcha- or bot-protected pages, closed shadow roots, and canvas/WebGL apps beyond a static frame. Authenticated pages need a user-provided browser session, and you still need the right to reproduce the page.
License
MIT
Available Tools
19 toolsaudit_reference_urlARead-onlyIdempotentInspect
Preflight check before cloning or embedding a URL, without launching a browser. Returns whether the page can be reused/embedded as-is, needs local browser capture, needs a logged-in session, needs manual review, or should be blocked, plus the next tool to call.
Inputs: url (required), license_text, source_signals, exact_requested, +1 more.
build_rebuild_scaffoldBInspect
Generate a bounded rebuild scaffold from an existing capture bundle when exact reuse is unavailable.
Inputs: capture_bundle (required), output_dir.
build_reproduction_bundleAInspect
Turn a capture bundle into an exact-reuse or reproduction bundle with persisted embed files when a trusted reuse path exists.
Inputs: capture_bundle (required), output_dir.
cancel_clone_jobAInspect
Move a queued or retry-wait clone job to cancelled.
Inputs: job_id (required), queue_root (required), reason.
capture_reference_bundleAInspect
Capture evidence for a URL with a real browser: runtime HTML, full-page screenshots, DOM and computed-style summaries, assets, network/HAR metadata, interactions, and optional desktop/tablet/mobile breakpoints. With output_dir and capture_html it also writes an offline HTML snapshot. Use when you will build or verify a page yourself.
Inputs: url (required), output_dir, capture_html, license_text, +12 more.
classify_clone_modeBRead-onlyIdempotentInspect
Decide whether a reference should be embedded, sourced, rebuilt, or blocked.
Inputs: candidates, license_text, site_profile, source_signals, +1 more.
clone_reference_urlAInspect
Clone a web page from its URL in one call. Use when the user asks to clone, copy, recreate, mirror, or make a page look exactly like a URL. Captures the live page in a real browser, reuses the original when it can be embedded, otherwise writes a self-contained offline HTML snapshot (inlined CSS, shadow DOM, localized fonts/images) or a rebuild, and self-verifies it against desktop/tablet/mobile screenshots. Returns the clone entrypoint, output directory, and fidelity scores.
Inputs: url (required), output_dir, capture_html, license_text, +12 more.
detect_runtime_capabilitiesARead-onlyIdempotentInspect
Report whether node, Playwright, and a usable Chrome/Chromium binary are available for session-aware capture.
Inputs: no named parameters.
discover_embed_candidatesBRead-onlyIdempotentInspect
Extract likely embed, preview, viewer, remix, and export candidates from a page.
Inputs: url (required), timeout_seconds.
enqueue_clone_jobAInspect
Persist a source-first clone job into a filesystem-backed async queue for later worker execution.
Inputs: url (required), queue_root (required), metadata, clone_args, +3 more.
generate_embed_snippetARead-onlyIdempotentInspect
Generate a ready-to-paste iframe embed snippet (HTML or Next.js) for a URL that is known to allow framing.
Inputs: url (required), title, framework.
inspect_urlARead-onlyIdempotentInspect
Inspect a URL before cloning: fetch it, read frame policy (X-Frame-Options/CSP), metadata, and platform signals, and summarize whether it can be embedded, sourced, or must be rebuilt.
Inputs: url (required), timeout_seconds.
list_clone_jobsBRead-onlyIdempotentInspect
List persisted clone jobs from the filesystem-backed async queue.
Inputs: queue_root (required), states.
load_clone_jobBRead-onlyIdempotentInspect
Load one persisted clone job by id.
Inputs: job_id (required), queue_root (required).
plan_reproduction_pathCRead-onlyIdempotentInspect
Produce a source-first execution plan using the current policy and capture bundle state.
Inputs: candidates, license_text, site_profile, capture_bundle, +2 more.
replay_har_requestsBInspect
Replay request specs against a standard HAR, near-HAR, or webEmbedding network manifest and return deterministic response matches.
Inputs: har_path (required), consume, requests, output_path.
run_clone_jobAInspect
Run one clone queue job, or the next due queued/retry-wait job when job_id is omitted.
Inputs: queue_root (required), job_id, worker_id.
trace_runtime_sourcesBInspect
Use a browser runtime to trace preview, embed, and scene URLs for a single viewport, with optional session-aware capture when Playwright is available.
Inputs: url (required), pattern, capture_html, wait_seconds, +6 more.
verify_fidelity_reportARead-onlyIdempotentInspect
Compare a reference capture against a candidate (e.g. your own implementation) and score visual, DOM, computed-style, and interaction similarity, listing the biggest differences to fix.
Inputs: candidate_url, reference_url, candidate_bundle, reference_bundle.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Several tools overlap around preflight decision-making: inspect_url, audit_reference_url, and classify_clone_mode all assess whether a URL can be embedded, sourced, rebuilt, or blocked. The granular pipeline tools (capture_reference_bundle, plan_reproduction_path, build_reproduction_bundle, build_rebuild_scaffold) versus the one-call clone_reference_url also create some selection ambiguity, though descriptions provide useful guidance.
Every tool follows a clear verb_noun snake_case convention (e.g., inspect_url, capture_reference_bundle, enqueue_clone_job, detect_runtime_capabilities). The convention is applied uniformly across capture, build, queue, and verification families.
19 tools is a bit heavy but justifiable for a multi-stage cloning pipeline with browser capture, fidelity verification, bundle building, and an async job queue. Each tool maps to a distinct pipeline stage or queue operation, though the surface could be tightened by merging overlapping preflight checks.
The surface covers the full lifecycle from URL inspection and policy auditing through capture, reproduction planning, bundle building, verification, one-call cloning, and job queue management. Minor gaps remain, such as explicit session/auth handling for logged-in captures and job deletion (cancel is the closest analog).
Maintenance
Related MCP Connectors
Captured web interfaces, screenshots, flows and structured evidence for AI coding agents.
Web infrastructure for AI agents: scrape, crawl and search the web, run browsers and agents.
Website checker for AI coding agents. Measures your site in a real browser, with evidence.
Browser-backed QA with evidence and fix-ready reports for coding agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides AI agents and coding assistants with advanced web crawling and RAG capabilities, allowing them to scrape websites and leverage that knowledge through various retrieval strategies.2MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to clone entire websites, download files, manage authentication sessions, and analyze site information with support for JavaScript-heavy SPAs and dynamic content.11Apache 2.0
- FlicenseNot gradedqualityCmaintenanceArchives live web pages for offline replay with full interactivity, enabling AI agents to analyze page structure and behavior.1-

QualityMax QA MCPofficial
AlicenseAqualityBmaintenanceEnables coding agents to independently verify web changes by scanning pages, inspecting UI structure, generating Playwright reproductions, and executing tests with structured QA evidence.464 npm4MIT