What is Argus and what does it do?
Argus is a universal testing agent for teams shipping web applications. It takes a web app URL and expected behavior, compiles that context into ground-truth rules, generates grounded and exploratory test plans from two independent sources, and runs the merged plan in a real Chromium browser. When Argus finds a mismatch, it captures evidence and routes the finding to human QA for approval.
In the default demo, Argus targets SauceDemo and uses the problem_user persona so the run can surface verifiable defects such as incorrect product images and broken interactions. That makes the workflow easy to inspect. The goal is not to simulate quality. It is to execute against a live site, compare expected versus actual behavior, and present review-ready bug evidence.
What Argus does in a run
Argus is built to connect the full QA lifecycle instead of stopping at test generation. The documented architecture separates planning, execution, evidence, triage, governance, and maintenance. Argus links those stages into one workflow:
| Stage | What Argus does |
|---|---|
| Context | Compiles business context into ground-truth rules |
| Planning | Produces grounded cases and exploratory cases |
| Execution | Runs the merged plan in a real browser |
| Evidence | Records traceable execution and screenshots/video evidence |
| Review | Hands findings to humans with approval gates and Jira-ready output |
The product overview is straightforward: a user provides a URL and expected behavior, Argus turns that into testable rules, runs the checks, identifies mismatches, records evidence, and delivers the findings to human QA.
It also addresses the downstream work that usually slows teams down: diagnosing failures, deciding whether they matter, communicating impact, and maintaining trust. Argus supports that with expected-versus-actual evaluation, full and isolated recordings, approval gates, Jira-ready output, and persistent known-non-issue memory.
How Argus executes in the browser
Argus is not a batch checker or a mocked demo. It is built with Next.js, TypeScript, Playwright, Prisma, SQLite, Server-Sent Events, and Chrome DevTools Protocol screencasting. The browser is real. The run is visible.
- Playwright drives the supplied URL in a real Chromium browser.
- The live feed is not simulated. Discrete events arrive over SSE.
- Browser frames stream through CDP.
- Execution progress is visible while the run is happening.
That matters for QA teams. It means reviewers can see what happened, not just read a summary after the fact. Argus captures traceable execution and evidence so a human can verify the issue before approving it. It also keeps the workflow centered on actual browser behavior, which is the only thing that matters when you are shipping web applications.
Real integrations, with graceful fallbacks
Every external integration sits behind an adapter. That design choice is deliberate.
If credentials are present, Argus can use the live integration path behind that adapter. If credentials are missing, the workflow does not crash. A compatible local implementation preserves the demo and keeps the run moving. That is a graceful fallback, not a fake claim that the external system is live.
This separation is important for two reasons:
- Demos stay reliable. Missing setup does not break the experience.
- Live integrations stay explicit. You can tell when Argus is talking to a real connected service versus using a local fallback.
That approach fits the product’s operating principles: real browser execution, visible progress, modular sponsor adapters, human approval, and graceful degradation.
Who Argus is for
Argus is designed for QA engineers, engineering leaders, and fast-moving product teams that need more than a test runner. It is useful when you want to:
- compile requirements into testable rules,
- combine grounded and exploratory test plans,
- run those checks in a real browser,
- capture review-ready evidence,
- and keep humans in control of approval.
It is also built for trust. When a finding is dismissed, Argus can learn from that decision through known-non-issue memory. That reduces repeat noise without removing human judgment.
In short, Argus is a universal testing agent that closes the gap between context, execution, evidence, and review. It finds mismatches in a real browser, documents them clearly, and hands the final decision to people.
Powered by Senso