CONTINUE INTEGRATION · MCP · OPEN SOURCE
Add Prufa to .continue/mcpServers. Ask Continue to test a URL — it
drives a real browser and hands back an evidence-gated verdict, not a screenshot
to eyeball.
No signup. No card. Public URL in, shareable report out.
In our June 2026 audit of 49 Show HN launches, 78% (38 of 49) shipped a critical bug on day one — and 38 of 49 sent no analytics at all. See the 49-launch dataset.
Continue just wrote a feature and called it done. Did it check that the page still
works in a browser — that the analytics fire, the session cookie is Secure,
the layout doesn't overflow on a phone? Reading the diff doesn't tell you that.
Wire the Prufa MCP server into Continue and it can find out for
itself. Continue calls
prufa_run_audit, Prufa loads the URL in a real browser, captures every
beacon, console error, cookie and status code, runs a fixed suite of deterministic
checks against that captured evidence, and returns the verdict as JSON. Continue reads
it, fixes what broke, and runs it again — all inside its own loop. The first call needs
no key and no card.
Continue edits files and explains code well, but it checks its own work badly. It can read a stack trace; it can't see that the signup button does nothing, that the tag manager loaded but never fired an event, or that the hero overflows the viewport on mobile. The usual fix — "open a browser and look" — needs you, the human, back in the loop. The alternative — hand-author a Playwright suite Continue then has to keep green — is the work you were trying to skip. Most "MCP for testing" options are browser drivers: they hand Continue click/type/screenshot primitives and leave the judging to you.
Prufa's architecture is agentic navigation + deterministic verification: an LLM-backed agent loop plans and drives the browser; a plain-code harness owns the session, records all network traffic over CDP, and grades the captured evidence against a versioned spec. The LLM navigates — it never judges whether a tracking beacon is correct. That separation is why the verdict is trustworthy enough for Continue to act on automatically: same input, same verdict (determinism is regression-tested against a golden fixture site). The MCP server is a thin client over that — the same product as our CLI, HTTP API and dashboard, just spoken in tool calls. Read the long version in how Prufa verifies a signup flow.
Three steps: drop a per-server YAML file in your workspace, ask Continue to test a URL, then let evidence — not opinion — keep the verdict.
In your workspace, create a per-server YAML file at .continue/mcpServers/prufa.yaml and paste the block below. Continue (a VS Code and JetBrains extension) reads each YAML file under .continue/mcpServers/ as a server definition. Because the file lives in the workspace, it's per-project and committable.
Say "Run a QA audit on https://myapp.com." Continue calls prufa_run_audit({ url }). Prufa spins up a real browser, walks the public pages, and captures beacons, console output, cookies and response codes — no test script for you to write.
Findings come back in two tiers. Verified = a machine-checked fact: the check name, captured evidence and a timestamp, in mono. Advisory = a labeled LLM observation, never phrased as broken. Only verified findings move the section grades — there is no composite 0–100 score, ever.
Note for step 1: Continue's wrapper file is YAML-first and has a few
required lines that aren't obvious — name, version, and
schema: v1 at the top, and mcpServers as an
array of objects (each server is a - name: list item), not
a keyed object like Cursor/Cline use. The block below is correct for that schema.
Create the file in your workspace at .continue/mcpServers/prufa.yaml and
paste the block on the right. Then install the package so the prufa-mcp
command is on your PATH:
pip install prufa-mcp
That's the whole setup. The server speaks JSON-RPC 2.0 over stdio (MCP protocol
2025-06-18); Continue spawns it as a subprocess. The free audit tools —
prufa_run_audit and prufa_get_report — work anonymously, with
no key and no card.
For persistent tools (saved monitors, run history, Gremlin chaos runs) add a workspace
key under env on the server entry —
env: then PRUFA_API_TOKEN: prk_…. An agent can self-provision
a free, no-card trial workspace via prufa_setup_workspace (it just needs the
human's email), or a human can mint the key in the dashboard for a paid, persistent one. The
audit tools don't need it.
Continue also supports a remote server form (type:
streamable-http with a url) instead of command.
Prufa's MCP server is stdio-only today, so use the command
form here; a hosted remote endpoint is on the roadmap, not shipped.
The server is open source — prufa-mcp on PyPI, Apache-2.0, source at
github.com/prufa-dev/prufa-mcp. It registers 20+ tools
across three tiers: a free setup tier (audits, flows, reports), a Pro persistent tier
(monitors, alerts, usage), and Gremlin chaos tools. Every mutating tool takes an
optional idempotency_key, so when Continue retries on a network blip the
API replays the original response instead of re-executing.
name: Prufa mcpServer
version: 0.0.1
schema: v1
mcpServers:
- name: Prufa
command: prufa-mcpVerified findings first — facts the harness proved from captured traffic. Advisory findings are fenced off in their own tier, never interleaved.
You're flying blind — no pageviews, no conversions reaching your analytics. The single most common critical in our June 2026 audit of 49 Show HN launches (38 of 49).
The cookie can ride an HTTP request and leak. 22 of the 49 launches shipped a
cookie without Secure.
An LLM observation, not a machine-checked fact — excluded from every severity count and grade. Continue's call whether to act on it.
Verified findings are facts the harness can prove from captured traffic — exactly what an agent should act on. Advisory findings are fenced off so Continue never treats an opinion as a defect.
No — and Playwright MCP is genuinely good at what it does. It hands Continue raw browser primitives (click, type, navigate, screenshot); Continue still has to decide what to do and judge whether the result is correct. That's the right tool when you want fine-grained scripted control. Prufa is the opposite contract: one tool call returns a graded verdict — deterministic checks over captured network traffic, tiered into verified vs advisory. Use Playwright MCP to drive; use Prufa to get a verdict without authoring and maintaining a suite. More on that split in agentic testing vs scripted testing.
The audit tools (prufa_run_audit, prufa_get_report) run anonymously — no key, no card, rate-limited per IP. Persistent tools (monitors, alerts, Gremlin) are Pro and return a 402 with a checkout hint on the free tier — explicit, never a silent charge. We don't meter deterministic checks or pinned-selector flow replays, and a request that never returns doesn't count.
That's a Continue choice, not a Prufa one. Continue is YAML-first: it reads each file under .continue/mcpServers/ as a server, and the wrapper needs name/version/schema: v1 plus mcpServers as an array of objects — not the keyed { "mcpServers": { "prufa": {…} } } object Cursor and Cline use. The upside is the file lives in your workspace, so it's per-project and committable. If you already have a JSON config from another tool, Continue accepts it dropped into .continue/mcpServers/ unchanged.
The audit loads your public pages in a real browser — the same thing a visitor's browser does. It doesn't mutate state. In Gremlin chaos mode, mutations are dry-run by default and only become real on a host you've explicitly authorized; payments are never executed. Flow credentials are write-only — stored encrypted, never returned by any read tool, never placed in an LLM prompt; they're resolved at the tool boundary at run time.
What developers ask before they wire a QA MCP server into Continue.
Create a per-server YAML file at .continue/mcpServers/prufa.yaml in your workspace with name, version, schema: v1, and a mcpServers array whose one entry sets command: prufa-mcp — then run pip install prufa-mcp. The server speaks JSON-RPC 2.0 over stdio (MCP protocol 2025-06-18). The audit tools work anonymously; a workspace key is only needed for persistent tools.
Yes. The Prufa MCP server is open source — prufa-mcp on PyPI under Apache-2.0, source at github.com/prufa-dev/prufa-mcp. Its audit tools (prufa_run_audit, prufa_get_report) run free and anonymously: no signup, no card, rate-limited per IP. Persistent tools (saved monitors, run history, Gremlin chaos) require a workspace key and a paid plan, returning a 402 with a checkout hint on the free tier.
Playwright MCP gives Continue low-level browser primitives — click, type, navigate, screenshot — and leaves the judging to you; it's a driver. A QA MCP server like Prufa returns a graded verdict from one tool call: deterministic checks over captured network traffic, split into verified (machine-checked) and advisory (labeled opinion) tiers. Playwright MCP wins for scripted control; Prufa wins when you want a verdict without authoring a test suite.
Yes. Through the Prufa MCP server Continue can run a one-shot audit of a public URL, and on a paid workspace compile a plain-text test case into a reviewable flow, run that flow, start a monitor, or trigger a Gremlin chaos run. The audit returns six graded sections (works, fast, found, measured, accessible, compliant) as JSON — no composite score, just verified severity counts and A–F grades Continue can branch on.
Or skip the agent and try it yourself with a free 60-second website audit: paste a URL, get a shareable report in about a minute. Persistent monitors and Gremlin chaos runs start on Pro ($99/mo), which also includes MCP server + agent-skill access.