Argus

Argus — The QA Layer for AI-Assisted Development

Your AI agent writes the code. Argus checks what it actually built.

One line in your MCP config gives Claude (or any MCP agent) a real Chrome audit engine — 67 audit categories · 149 finding types · zero test files to write or maintain. And with Aegis, what it finds never leaks your secrets to the LLM.

[▶ See it in action → argus-qa.com](https://argus-qa.com)

Quick Start · The Fix Loop · What It Catches · Your Stack · MCP Tools · Full Setup · Reference

Why Argus Exists

AI agents now write most of the code — and they judge their own work by whether it *compiles and looks done*, not by what actually happens in the browser. The uncaught exception on the third click. The form that posts credentials over HTTP. The 4-second LCP. The button that vanished in dark mode. The API endpoint hammered in an infinite loop.

Argus closes that gap. It drives a real Chrome (via the Chrome DevTools Protocol) against your locally-running app and hands the agent — or you — a structured, severity-ranked bug report. The agent fixes; Argus re-checks; the loop closes *before* the code leaves your machine.

Quick Start

No install. npx fetches Argus on first run.

1 — Add two lines to `.mcp.json` in your project root:

{

"mcpServers": { "chrome-devtools": { "command": "npx", "args": ["-y", "chrome-devtools-mcp@latest"] }, "argus": { "command": "npx", "args": ["-y", "argusqa-os"] } } }

Or via the Claude Code CLI:

claude mcp add chrome-devtools -- npx -y chrome-devtools-mcp@latest

claude mcp add argus -- npx -y argusqa-os

2 — Launch Chrome (auto-detects your Chrome, sets the right flags):

npx -y -p argusqa-os argus-chrome

Prefer launching Chrome manually? (macOS / Windows / Linux commands)

# macOS

open -a "Google Chrome" --args --remote-debugging-port=9222 --headless=new

Windows (PowerShell)

& "C:\Program Files\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222 --headless=new --no-sandbox --disable-gpu --user-data-dir="$env:TEMP\chrome-argus"

Linux

google-chrome --remote-debugging-port=9222 --headless=new --no-sandbox

3 — Ask your agent:

Run argus_audit on http://localhost:3000

That's it. Findings come back structured and severity-ranked — into the conversation, to Slack, or as a local report.html. Something off? npx -y -p argusqa-os argus-doctor diagnoses your setup in one command.

The Fix Loop

This is what Argus looks like inside an agentic coding session:

You:    Build me a checkout page with a card form.

Agent: [writes the code, dev server renders it]

You: Run argus_audit on http://localhost:3000/checkout Argus: ● 2 critical · 3 warnings ● uncaught TypeError in checkout.js (visible on submit) ● form posts over HTTP — security_no_https ▲ card inputs missing labels + autocomplete (a11y/WCAG) ▲ LCP 4.1s — hero image unoptimized ▲ duplicate POST /api/cart ×7 — likely render loop

Agent: [fixes all five]

You: Run argus_get_context Argus: ✓ resolved: 5 · persisting: 0 · new: 0

argus_get_context diffs against the previous snapshot, so the agent knows exactly what it fixed, what it broke, and what remains — no re-reading walls of output.

"But my agent can already drive a browser…" — it can. Driving isn't judging. A raw browser MCP (Playwright MCP, bare chrome-devtools-mcp) gives the agent hands and eyes; the agent must then *re-derive what to check* every session, burning context on console-log spelunking. Argus is the judgment layer on top: 149 codified finding types with thresholds, severity policy, cross-run baselines, flakiness filtering, dedup, root-cause hints — returned in one call, redacted by default.

What Argus Catches

32 analysis engines, 149 distinct issue types, zero test-file maintenance:

And every finding is post-processed with:

All findings are classified as critical / warning / info and routed to the right Slack channel — or surfaced in the local HTML report. For per-finding severity tables and detection methods, see REFERENCE.md.

Works With Your Stack

Argus audits the rendered output, not your source — so it is framework-agnostic by construction. If it runs in Chrome, Argus can audit it:

Honest limits: Chrome/Chromium rendering only (no Safari/Firefox engine differences), web only (no native mobile/desktop apps), and backend services are checked through the traffic the page generates — not as standalone API test suites.

Confidentiality — Aegis Egress Boundary

Default ON. Argus audits your app for *secrets and vulnerabilities* — so its findings are exactly the data you least want leaving your machine. Aegis redacts them at every external boundary before they cross. For teams adopting AI agents, this is the difference between "we use an AI QA tool" and "we can tell our security lead exactly why it's safe."

A finding sent to an external sink — an MCP tool response (which lands in the calling agent's context window and transits to that agent's model provider), a Slack message, a GitHub PR comment + its ::error annotations, the hosted/CI HTML report, or CI logs — is reduced to a need-to-know projection: a sensitive finding crosses as its type + route + severity + a 🔒 marker, and never its raw payload (message, evidence, request/response bodies, headers, cookies, stack). URLs are projected with the query string stripped (tokens hide there). A benign finding keeps its message — but that message is still scrubbed for any accidentally-embedded secret or PII.

This implements the OWASP LLM02:2025 — Sensitive Information Disclosure mitigations (data minimization, redaction, deny-by-default egress filtering) at Argus's own boundaries. An optional, local-only re-hydration vault (ARGUS_REDACT_VAULT=1) can mint reversible, information-free tokens for diff-stable artifacts — re-inflate locally with npm run report:rehydrate. Full behavior change is documented in CHANGELOG.md.

MCP Tools

Ask Claude (or any MCP client) — no terminal required:

| argus_watch_snapshot | Snapshot the open tab without navigating (preser