Lastest MCP server
Commit Nov 11, 2026A visual regression testing platform that uses AI to record, generate, and fix Playwright tests for web applications.
Also known as las-team/lastest
- Stars
- 22
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 11, 2026
- License
- —
What is Lastest MCP?
Lastest is a visual regression testing platform that uses AI to record, generate, and fix Playwright tests for web applications.
Summary generated from the project's README
About Lastest MCP server
Visual regression testing for web applications is what Lastest provides through an AI-driven platform that records, generates, and maintains Playwright tests. Developers and QA teams use this self-hosted tool to ensure UI changes do not break existing functionality. It operates by running every test inside an Embedded Browser container, which can be provisioned automatically via k3d or Kubernetes, or brought by the user using a docker container.
Users can choose between manual recording without AI, human-in-the-loop assistance where AI proposes fixes, or a fully autonomous Play Agent that handles an 11-step pipeline from route scanning to failure repair. The system compares screenshots using pixelmatch, SSIM, or Butteraugli engines to detect visual regressions. Because it is self-hosted, all screenshots and data remain within your own infrastructure. The platform supports various testing types including headless HTTP API tests and design system verification to catch drift in colors or typography.
What you can do with it
- 1Automated UI regression detectionA developer can use the platform to automatically identify if a recent code commit has visually altered the user interface.
- 2Autonomous test suite generationAn engineer can kick off a single-click pipeline to scan routes and generate full test coverage for a new project.
- 3AI-driven test repairWhen a Playwright test fails due to a UI change, the AI can propose a code fix for a human to review.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
DATABASE_URLEARLY_ADOPTER_PRICINGEB_IMAGEEB_NAMESPACEEB_PROVISIONEREMAIL_FROMENCRYPTION_KEYGITHUB_CLIENT_IDGITHUB_CLIENT_SECRETGITHUB_REDIRECT_URIGITHUB_WEBHOOK_SECRETGITLAB_CLIENT_IDGITLAB_CLIENT_SECRETGITLAB_INSTANCE_URLGITLAB_REDIRECT_URIGITLAB_WEBHOOK_SECRETGOOGLE_CLIENT_IDGOOGLE_CLIENT_SECRETGOOGLE_REDIRECT_URIGOOGLE_SHEETS_REDIRECT_URILASTEST_URLMONITORED_BRANCHESNEXT_PUBLIC_APP_URLNEXT_PUBLIC_BASE_URLOCR_SERVICE_URLOLD_ENCRYPTION_KEYRESEND_API_KEYSTRIPE_AUTOMATIC_TAXSTRIPE_SECRET_KEYSTRIPE_WEBHOOK_SECRETSYSTEM_EB_TOKEN
| Name | Description | |
|---|---|---|
| DATABASE_URL | — | |
| EARLY_ADOPTER_PRICING | — | |
| EB_IMAGE | — | |
| EB_NAMESPACE | — | |
| EB_PROVISIONER | — | |
| EMAIL_FROM | — | |
| ENCRYPTION_KEY | — | |
| GITHUB_CLIENT_ID | — | |
| GITHUB_CLIENT_SECRET | — | |
| GITHUB_REDIRECT_URI | — | |
| GITHUB_WEBHOOK_SECRET | — | |
| GITLAB_CLIENT_ID | — | |
| GITLAB_CLIENT_SECRET | — | |
| GITLAB_INSTANCE_URL | — | |
| GITLAB_REDIRECT_URI | — | |
| GITLAB_WEBHOOK_SECRET | — | |
| GOOGLE_CLIENT_ID | — | |
| GOOGLE_CLIENT_SECRET | — | |
| GOOGLE_REDIRECT_URI | — | |
| GOOGLE_SHEETS_REDIRECT_URI | — | |
| LASTEST_URL | — | |
| MONITORED_BRANCHES | — | |
| NEXT_PUBLIC_APP_URL | — | |
| NEXT_PUBLIC_BASE_URL | — | |
| OCR_SERVICE_URL | — | |
| OLD_ENCRYPTION_KEY | — | |
| RESEND_API_KEY | — | |
| STRIPE_AUTOMATIC_TAX | — | |
| STRIPE_SECRET_KEY | — | |
| STRIPE_WEBHOOK_SECRET | — | |
| SYSTEM_EB_TOKEN | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablelas-team/lastest is public and reachablegithub.com/las-team/lastest ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)No licenseFinding
- Commit or release in the last yearLast commit or release 2026-11-11github.com/las-team/lastest ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubThe Problem
Visual regression testing is either expensive, flaky, or painful to maintain.
- Cloud tools: per-screenshot pricing, cloud-only, no self-hosting
- Enterprise tools: steep learning curve, locked to specific frameworks
- Open-source tools: free but no dashboard, no collaboration, no AI, or in maintenance mode
Meanwhile, you just need to know: "Did my last commit break the UI?"
The Solution
Lastest is a free, self-hosted visual regression testing platform that records your tests, writes them with AI, runs them anywhere, and fixes them when they break — all in one tool.
1. Point it at your app
2. Record your user flows (point-and-click, no code)
3. AI generates resilient test code with multi-selector fallback
4. Every test runs inside an Embedded Browser container (EB stack required)
5. Screenshots compared with 3 diff engines (pixelmatch, SSIM, Butteraugli)
6. Review and approve visual changes — or let AI auto-classify them
When self-hosted, your data stays on your server and your screenshots never leave your infra.
Three Ways to Work
Lastest adapts to how you want to build tests — from fully manual to fully autonomous.
1. AI-Free (Manual Recording)
Open the recorder, click through your app, hit stop. Lastest captures every interaction and generates deterministic Playwright code — no AI involved, no API keys needed. You own the test code and can edit it by hand.
Best for: Teams that don't want AI, air-gapped environments, simple flows.
2. AI-Assisted (Human-in-the-Loop)
AI generates, fixes, or enhances tests — but you review and approve before anything is saved. Feed it a URL and get a test back. Import OpenAPI specs or user stories and AI extracts test cases. When a test breaks, AI proposes a fix and you decide whether to accept it.
Best for: Day-to-day development, iterating on tests, fixing breakages fast.
3. Full Autonomous (Play Agent)
One click kicks off an 11-step pipeline: check settings, select repo, set up environment, scan routes & apply testing template, plan functional areas, review plan, generate tests, run them, fix failures (up to 3 attempts per test), re-run, and report results. Uses specialized sub-agents (Orchestrator, Planner, Scout, Diver, Generator, Healer). The agent pauses and asks for help only when it hits something it can't resolve on its own. You resume and it picks up where it left off.
Best for: Onboarding a new project, generating full coverage from scratch, CI bootstrapping.
One Way to Run: Embedded Browser
Every test runs inside an Embedded Browser (EB) pod — a containerized Chromium with live CDP streaming back to the UI. There is no local-Playwright fallback and no remote-runner daemon anymore: the host never launches its own browser, and if an EB is unavailable a test fails rather than falling back. The EB stack is therefore required for every run and recording, even in local development.
- System-managed (default) — EB pods are provisioned automatically: into a local k3d cluster in dev, or your Kubernetes cluster in production, from an on-demand pool (worker-pool per build, warm-pool keep-alive, egress-restricted). One EB per test.
- Bring-your-own (BYO) — run the
lastest-ebcontainer yourself (docker run … -p 9223:9223 -p 9224:9224) and register it in Settings → Runners to get a token. This is the replacement for old "remote runners": you bring a browser on the machine/network/OS you want, not a Playwright daemon.
EB pods handle both running and recording. Builds can be triggered manually (click Run), by webhook (PR opened/updated), from CI/CD (GitHub Action or the @lastest/runner CLI, which only triggers a build and polls — execution still happens in the EB pool), or on a schedule (cron-based automation). Smart Run analyzes git diffs to run only affected tests.
Migrating from remote runners? The standalone runner daemon that executed Playwright on remote machines has been retired. To run tests on your own machine/network, register a BYO Embedded Browser instead. The
@lastest/runnernpm package lives on as a lightweight, browser-free CI trigger client only.
Build Once, Run Forever
Tests are recorded or generated once, then stored as code. Every subsequent run re-executes the same code, captures new screenshots, and diffs them against approved baselines.
- First run: screenshot becomes the baseline
- Every run after: new screenshot is SHA256-hashed — if it matches the baseline, instant pass (no pixel comparison needed). If it differs, the diff engine runs and you review the change.
- AI costs are one-time: AI is only used during test creation and fixing. Running tests uses zero AI — it's pure Playwright execution.
- No per-screenshot pricing on self-hosted: every run is unlimited regardless of volume.
Create tests (one-time) Run tests (forever)
┌──────────────────────┐ ┌──────────────────────┐
│ Manual recording │ │ Execute Playwright │
│ — or — │ ────▶ │ Capture screenshots │
│ AI generation │ save │ Diff against baseline │
│ — or — │ │ Review changes │
│ Play Agent autonomy │ │ Approve/reject │
└──────────────────────┘ └──────────────────────┘
AI may be used here No AI needed here
Features
Core
- Record Browser Interactions — Point-and-click test recording via Playwright with multiple engines (custom recorder or Playwright Inspector). No code required.
- AI Test Generation — Claude generates robust test code with multi-selector fallback (data-testid → id → role → aria-label → text → css → OCR).
- Multi-Engine Visual Diffing — Three comparison engines: pixelmatch (pixel-perfect), SSIM (structural similarity), and Butteraugli (human-perception-aligned). Choose the best trade-off between speed and accuracy.
- Multi-Step Screenshots — Capture multiple labeled screenshots per test run for multi-page flow testing.
- Approval Workflow — Review visual diffs before they become baselines. Catch regressions, approve intentional changes.
- Check Modes — Unified verification control across 9 layers (visual, text, DOM, network, console, a11y, design, performance, URL), each set to enforce, log, or disable per repo — replacing scattered per-feature toggles.
- Verify Board — Per-step card board for reviewing multi-layer check results: change map, per-layer baselines, and reviewer feedback in one focused view. Verify is now the single execution surface: the old
/runand/buildspages were retired into it, bringing the build-history graph (header drawer), the smart/all/comparison run split-button, "Accept all safe" on unsorted diffs, live EB streaming during a build, and the step-label editor. - Environments — PROD / UAT / prerelease deployments of the system under test as a first-class object (
key,label,baseUrl,releaseLabel,refreshedAt), with per-environment variables and baselines. Run one suite against UAT and PROD without the two fighting over one set of approvals; promote baselines between environments and survive a vendor sandbox refresh. Fully additive — a repo that never creates an environment behaves exactly as before. - Per-Repo Credential Store — Named credential sets encrypted at rest (AES-256-GCM) and injected into the test process at run time via a dedicated
credentialsparameter, never through variable substitution — so rotating a password does not changecodeHash, invalidate a baseline, or land in plaintext run records. - App Map + Explore — A live map of your app's screens, routes, and flows, built by a multi-EB swarm crawler that explores in parallel. Tree outline, screens gallery, node detail, and flow playback; feeds route discovery and test planning.
- Interactive Test Playback — Replay a recorded run step-by-step in the UI with the captured evidence layer (including storage state) attached to each step.
- Run Results (Triage) — Build-scoped results screen that clusters failures by root cause rather than functional area, writes a run-level narrative, and suggests a verdict per cluster with reviewer verdicts tracked separately.
- GitHub Issues with Full Evidence — Open an issue carrying the complete failure evidence (screenshots, diffs, console/network), optionally assign an AI engineer, and auto-close on confirm-when-green.
- Design System Verification — Design-token comparison layer that flags drift from your design system (colors, spacing, typography) as its own check layer.
- URL Diff — Capture and diff URL trajectories across runs to catch unexpected redirects and navigation changes.
- API Tests — Headless HTTP API testing as a first-class test type (
method/url/headers/query/body/auth+ assertions). Runs in-process with no browser or EB dispatch, feeds the same step-comparison and verdict pipeline as browser tests, and can be generated from captured network calls. Includes a burst/load runner for firing concurrent requests at an endpoint (single up-front SSRF validation, per-connection re-check). - Analyze URL — Pre-recording selector tuning: scans the target page, measures selector-strategy coverage (data-testid, aria, ids, …), and recommends a priority order matched to your app.
- Git-Aware Builds — Run tests per branch/commit. Compare across PRs. Track coverage.
- Branch Comparison — Dedicated compare view for side-by-side branch-to-branch test result diffing.
- Test Suites — Organize tests into ordered suites for structured execution.
- Test Versioning — Full version history with change reasons (manual edit, AI fix, AI enhance, restored).
- Test Composition — Cherry-pick tests and pin specific test versions per build via the Compose page. Override latest with any historical version.
- Functional Area Hierarchy — Organize tests into nested parent/child functional areas with drag-and-drop reordering.
- Debug Mode — Step-by-step test execution with live feedback for diagnosing failures.
- Testing Templates — One-click preset configurations for common app types: SaaS/Dashboard, Marketing Website, Canvas/WebGL, E-commerce, Documentation, Mobile-First, SPA, and CMS.
- Auto-Detect Capabilities — Recording automatically detects required browser capabilities (file upload, clipboard, downloads, network interception) and enables corresponding Playwright settings.
- Early Adopter Mode — Team-level toggle to access experimental features before general release.
- Scheduled Test Runs — Cron-based automated builds with preset schedules (daily, weekly, hourly) or custom cron expressions. Auto-disables after consecutive failures. Optional branch targeting.
- Success Criteria Tab — Parsed assertion tracking per test: see which
expect()calls passed/failed with expected vs actual values, error messages, and code line references. - WCAG 2.2 AA Compliance Scoring — Automated 0–100 accessibility score per build with severity-weighted deductions (critical/serious/moderate/minor), trend sparklines across builds, and per-test violation detail.
- Guided Onboarding — 8-step setup guide for new users: connect GitHub, configure AI, scan routes, record first test, run, set baselines, re-run, check results. Auto-detects completion.
- AI Failure Triage — Automatic classification of test failures into real regression, flaky test, environment issue, or test maintenance — with confidence scores and reasoning.
- Bug Reports — In-app bug reporting with auto-captured context (URL, viewport, console errors, failed requests, breadcrumbs), screenshot attachment, and GitHub issue creation.
- Review Todos — Branch-specific actionable items created when a reviewer flags a diff. Track review feedback as todos tied to specific builds and tests.
- Gamification (Beat the Bot) — Competitive scoring layer where humans compete against AI bots on a team leaderboard. Earn points for creating tests (+10), catching regressions (+100), approving real changes (+15), resolving review todos (+5). Small flaky-test penalty (−5, daily-capped). Seasonal play with named seasons, achievements (first test, first regression, beat-the-bot tiers), and Bug Blitz events with configurable multipliers (2–5×). Team-level toggle. Celebratory toasts on score events via SSE.
- Leaderboard — Ranked season standings for humans and bots with top-3 podium styling, per-actor breakdowns (tests created, regressions caught, flakes incurred), and "you are here" row for viewers outside the top 10.
- Public Share Links — Publish a run, build, or diff as a watermarked, publicly-viewable
/r/<slug>report — no login required for viewers. Includes optional AI-written demo notes, session video (WebM with MP4 conversion + fallback), zip download of artifacts, and social-share flows with media-aware cards for X, YouTube, and TikTok. Links are revokable and reuse a stable URL on re-publish. - Test Migration — Move tests and functional areas between Lastest instances. Connect to a remote instance via URL + API key, browse remote repos, and import with idempotent name-based upsert. Also available via REST API (
GET /export+POST /import). - API Tokens — Generate long-lived Bearer tokens (
lastest_api_*) for the MCP server, VS Code extension, CI scripts, and cross-instance migration. Revokable per-user with labels.
AI-Powered
- Multiple AI Providers — Claude CLI, OpenRouter, Claude Agent SDK, direct Anthropic API, OpenAI, or Ollama (local models).
- Separate AI Diff Provider — Use a different AI provider for diff analysis than test generation.
- AI Diff Analysis — AI-powered visual diff classification (insignificant/meaningful/noise) with confidence scores and change categories.
- AI Test Fixing — Automatically fix failing tests or enhance existing ones.
- Fix-the-App Advisor — When a failure is classified as a real regression, AI produces a structured application-code fix recommendation (file, snippet, rationale, confidence) by localizing the root cause against recently-changed files. Distinct from the test healer — it patches your app, not the test — and it never auto-applies: it hands the suggestion back to you or your coding agent. Exposed via the MCP
suggest_app_fixtool. - Diff-Scoped Validation — AI validates and decides on individual visual diffs (
validate_diff/decide_diff), scoping analysis to a single diff for precise, low-noise verdicts. - Spec-Driven Testing — Import OpenAPI specs, user stories, or markdown files. AI extracts stories and generates tests automatically.
- Route Discovery — AI scans your source code to discover routes and suggest tests.
- MCP Selector Validation — Real-time selector validation on live pages via Claude MCP.
- Play Agent (Autonomous) — One-click 11-step pipeline: check settings → select repo → environment setup → scan & template → plan areas → review → generate tests → run → fix failures (up to 3 attempts) → re-run → summary. Uses specialized sub-agents (Orchestrator, Planner, Scout, Diver, Generator, Healer). Pause/resume, approve plans, skip steps.
- Agents Console —
/agentsis the single entry point for agent work: one roster of every agent working the selected repo, what each is doing, what it is blocked on, and which embedded browsers it is holding. Paused (browser released) and blocked-on-a-human (browser still held) are shown as different states, and escalations from parked sessions and pushed-back tasks are merged into one queue. Drill into a row to reach the QA agent, the Triage agent, the Healer, or the Explorer (Ranger, Play and QuickStart are one-shot onboarding flows and have no roster row). Pro-plan gated. - QA Agent — Autonomous comprehensive-suite builder on an eight-phase pipeline: preflight → discovery (static GitHub-tree route scan + live EB crawl with verified selectors and observed API endpoints) → risk-prioritized plan → human plan review (approve / exclude / send feedback) → generation (one test per plan item over the EB's CDP endpoint) → run → heal → summary. Console shows a live pipeline strip, coverage matrix, direction queue, and activity feed.
- Triage Agent — Replaces the two independent AI passes (per-diff analysis and per-test failure triage) with one build-scoped classifier that groups by root cause, ranks by risk, and suggests verdicts.
- Healer Agent — After triage, repairs failing tests in a heal → verify loop and stops itself. It only touches failures triage classified as a test problem (
test_maintenance,flaky_test); real regressions, environment issues, unclassified failures and cases a reviewer already decided are left red with the reason recorded. Hard stops: a per-test attempt budget (default 2, counted fromai_fixversions since the test last passed or was hand-edited), a per-build cap (default 5), an identical-error no-progress guard, one campaign per repo at a time, and heal/verify timeouts. Every patch is a versionedai_fixedit you can revert./healer-agentowns the toggle, the budgets, a Stop button and a per-test outcome ledger. - Agent Monitoring & Activity Feed — Real-time tracking of Play Agent sessions with step-by-step progress, SSE streaming, and session history. Monitor active/paused/completed agents from the dashboard.
- Codebase Intelligence — Automatic detection of project context (framework, CSS framework, auth, state management, API layer, key dependencies) to enrich AI prompts. 100+ package database mapping dependencies to testing recommendations.
Stabilization & Flaky Test Prevention
- Text-Region-Aware Diffing — OCR-based two-pass comparison with separate thresholds for text vs non-text regions. Reduces false positives from dynamic text and cross-OS font rendering.
- Timestamp Freezing — Replace
Date.now()andnew Date()with fixed values for deterministic screenshots. - Random Value Seeding — Seed
Math.random()for consistent outputs. - Cross-OS Consistency — Bundled fonts + Chromium flags for identical screenshots across operating systems.
- Burst Capture — Multi-frame instability detection: take N screenshots and compare for stability before saving.
- Auto-Mask Dynamic Content — Automatically detect and mask timestamps, UUIDs, and relative times before comparison.
- Network Idle Waiting — Wait for network activity to settle before capture.
- DOM Stability Detection — Wait for DOM mutations to stop before screenshot.
- Third-Party Blocking — Block third-party domains with configurable allowlist, mock external images.
- Font Loading Wait — Wait for webfonts to load, or disable them entirely.
- Loading Indicator Hiding — Auto-hide spinners and loading states with custom selectors.
- Page Shift Detection — Detect vertical content shifts (inserted/deleted rows) with fuzzy row matching.
Integrations
- GitHub — OAuth login, repo sync, PR comments, webhook-triggered builds, reusable GitHub Action.
- GitLab — OAuth login (self-hosted supported), MR comments, webhook triggers.
- Google OAuth — Sign in with Google.
- SUT Connectors (Veeva Vault, Salesforce) — Connect directly to the system under test: N connectors per type per repo, each bound to an environment and pointing at a credential set. Profiles the target over its real REST API to ground test generation in the live configuration.
- Google Sheets — Use spreadsheet data as test data sources with per-team OAuth, multi-tab support, custom header rows, fixed ranges, and caching.
- Notifications — Slack, Discord, custom webhooks, and GitHub/GitLab PR comments for build results.
- Email — Team invitation emails via Resend.
Lastest MCP questions
Can I run Lastest on my own infrastructure?
Yes, Lastest offers a self-hosted version where your data and screenshots stay on your own server.
Does running tests require AI?
No, AI is only used during the creation and fixing of tests; the actual execution is done via pure Playwright.
What engines are used for visual diffing?
Lastest uses three different engines: pixelmatch, SSIM, and Butteraugli.