Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Jev Browser Pro — QA flows run by a guarded browser agent

    1

    **What you get** - **QA flows**: TOML regression tests for your app, with Markdown and JSON reports.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Jev Browser Pro — QA flows run by a guarded browser agent

    Jev Browser Pro — QA flows run by a guarded browser agent

    Example session with this skill installed

    Run the QA flows in examples/flows against the demo site and write the report to demo-report.md.

    • Read your context and instructions
    • Compiled the jev browser pro

    Summary

    All 3 steps of the demo flow passed. The booking button was stopped before the click, as the flow expects. Model cost: $0.0005.

    QA report — 2026-11-14T17:17:15

    3 passed, 0 failed, 0 skipped · model cost $0.0005

    FlowStepResultGoalAgent statusTime
    Demo stays: search, filter, open, booking is guarded1PASSType Lisbon as the destination, tick Free cancellation and search. Stop when the results are visible.done3.8 s
    Demo stays: search, filter, open, booking is guarded2PASSOpen Casa Flora. Stop when its page is visible.done0.8 s
    Demo stays: search, filter, open, booking is guarded3PASSClick Book now.needs_confirmation0.5 s

    The flow behind it (examples/flows/demo.toml):

    name = "Demo stays: search, filter, open, booking is guarded"
    base_url = "http://127.0.0.1:8800"
    allowed_domains = ["127.0.0.1"]
    
    [[step]]
    goal = "Type Lisbon as the destination, tick Free cancellation and search. Stop when the results are visible."
    path = "/index.html"
    expect_url = "q=Lisbon"
    expect_text = ["Results for Lisbon", "Casa Flora"]
    expect_no_text = ["Rio Hostel", "No stays found"]
    
    [[step]]
    goal = "Open Casa Flora. Stop when its page is visible."
    expect_text = ["Casa Flora", "Book now"]
    
    [[step]]
    goal = "Click Book now."
    expect_status = "needs_confirmation"
    expect_no_text = ["Booking confirmed"]
    

    Next steps

    • Copy the demo flow and point base_url and allowed_domains at your own app.
    • Run uv run jev_flows.py run flows --report report.md in CI; it exits 1 when any step fails.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Describe a user journey in a few lines of TOML — "search for Lisbon, tick Free cancellation, open Casa Flora, Book now must be guarded" — and get a pass/fail report you can run before every merge. No selectors to maintain: an AI browser agent does the clicking, and your own checks decide each step (URL, text that must or must not be on the page, and whether a destructive button was stopped). The agent's claim that it finished never counts: a step passes only when the checks you wrote in the flow pass. Guarded clicks, a domain allowlist and a one-file runner for CI come in the box.

    What you get

    • QA flows: TOML regression tests for your app, with Markdown and JSON reports.

    • A one-file runner (jev_flows.py, Python standard library only) that your agent saves into your project, so the same flows run from the agent, the shell or CI (exit code 0/1).

    • Expected-guard checks: prove that "Book now", "Delete account" or "Place order" cannot be clicked by an agent without approval.

    • A skill that teaches your agent to write flows for your app and to read every result.

    • A demo app and example flow that run in under a minute, recipes and troubleshooting.

    • The browser tool itself, browse_interactive, as an MCP server you set up once with a few copy-paste commands (SETUP.md, no installer). It provides:

    • A mandatory domain allowlist. Off-domain links are refused before the click. A redirect is caught after the page loads, and the run stops there.

    • A stop before buy, pay, delete, send, publish or register clicks, and before an Enter that would submit such a form.

    • Step and time budgets, loop detection, and a re-check of the final page with the fast backend.

    Built on an open-source core. The server is the MIT project jev-browser-mcp (github.com/mjvmsteixeira/jev-browser-mcp), bundled so the package works on its own. The flows, the runner, the skill, the demo and the setup guide are what this package adds.

    Two backends

    • Fast (recommended): with a TypeSafe API key, decisions run on the Jev model. Steps take seconds and cost fractions of a cent. The demo flow cost $0.0005.
    • Local: without a key, decisions run on Ollama on your machine and no page text leaves it. It is much slower and far less reliable (in our benchmark it completed 1 of 7 tasks), so use it only for short steps.

    Honest limits

    • No iframes, shadow DOM, canvas, file uploads or pop-ups.
    • Steps start from a URL, so in-memory SPA state doesn't carry between steps.
    • Long forms with many custom widgets are not completed reliably in one step.

    Requirements: uv, Google Chrome or Chromium, and Ollama with a local model to type text into fields: the default (~19 GB, best accuracy and injection resistance) or gemma3:4b (3.4 GB, benchmarked as the best small one, weaker against prompt injection). A TypeSafe key is optional.

    What is written and sent, disclosed (details in SETUP.md):

    • Setup writes ~/.jev-browser (the server and its dependencies, the dedicated Chrome profile), the local model, and your agent's MCP config. You run each step yourself; nothing runs as root.
    • Setup downloads the pinned Python dependencies (including jev-ultrafast from GitHub), Python 3.12 through uv if missing, and the local model.
    • The runner starts the server on your machine over MCP (stdio), reads only the flow files you name and writes only the reports you name, plus a server log in your temp folder.
    • The browser visits only the domains in each flow; with a TypeSafe key, each page's visible text goes to api.typesafe.ai. No telemetry.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Testing & Debugging.

    No iframes, shadow DOM, canvas, file uploads or pop-ups. Steps start from a URL, so in-memory SPA state doesn't carry between steps. Long forms with many custom widgets are not completed reliably in one step. The local backend is much slower and far less reliable than the fast one.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    Software
    uv (Python tool runner)
    Google Chrome
    orChromium
    Ollamaa local modelPythonJev Browser MCP
    Optional
    TypeSafe API key

    Tested end to end on Claude Code on macOS; Linux should work but is untested. Not for Windows. The MCP server is bundled; set it up once from SETUP.md.

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables
    Browser

    Allowed Hosts

    api.typesafe.ai

    Shell runs the runner and the local MCP server; files are the flows you name, the reports you name and ~/.jev-browser; the browser visits only the domains in each flow. With a TypeSafe key, visible page text goes to api.typesafe.ai. Setup downloads pinned Python deps, Python 3.12 via uv if missing, and the local model. Nothing runs as root. No telemetry.

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    A plain agent decides for itself whether it succeeded. Here each step passes or fails only on the checks you wrote in the flow: the URL, text that must or must not be on the page, and whether a destructive button was stopped. The agent's own "done" never counts.

    Tested end to end on Claude Code on macOS. Other agents that run stdio MCP servers (such as Cursor or Codex CLI) and Linux should work but have not been tested end to end. Not for Windows.

    The skill (how to write flows and read results), the one-file runner jev_flows.py, a demo app with an example flow, recipes and troubleshooting, and the browse_interactive MCP server (from the MIT project jev-browser-mcp) with a manual SETUP.md. There is no installer.

    Yes. The runner exits 0 when every step passes and 1 otherwise, and writes Markdown and JSON reports. The CI machine needs the same setup as your own: uv, Chrome or Chromium, and Ollama with a local model, plus a TypeSafe key if you use the fast backend.

    Without a TypeSafe key, nothing: decisions run on Ollama locally. With a key, each page's visible text goes to api.typesafe.ai. The browser visits only the domains listed in each flow. No telemetry.

    New in Testing & Debugging