Agentic quality assurance
DeepQA boots the app behind your PR in a sandbox and puts an agent team on it in a real browser.
Evidence on every issue. An adversarial audit before anything ships.
Explore live resultsRequest early access1 Intake
2 Explore
3 Plan
4 Test
5 Critique
6 Report
Invoices
Scenarios
Report
41 issues published
Polymedia BIDDERSui Campaign7/8scenarios passedNo issues after the auditSep 27, 2026
CallItSui Campaign9/12scenarios passed2 issues, 1 highSep 27, 2026
FlickySui Campaign4/11scenarios passedPassedSep 27, 2026
PelagosSui Campaign10/12scenarios passedNo issues after the auditSep 27, 2026Campaigns
A campaign takes a group of apps that people actually use and puts each one through the whole pipeline. Every report is published as it lands, and the numbers below are read from those published runs.
Celebrating Circle's Arc mainnet launch: DeepQA tests apps in the Arc ecosystem in place, most of them with an injected test wallet on Arc testnet.
DeepQA tests apps in the Sui ecosystem in place, with an injected QA wallet on Sui testnet.
DeepQA tests agent apps that are trending on GitHub: workflow builders, chat UIs, coding agents, research agents and observability tools.
Web3
dApps tested the way a user meets them, on a real chain.
The web3 network side of DeepQA.
DeepQA checks whether your app is testable before it boots anything, hard-stops at the cap you set, and lets you end a Run while it is still going.
12 scenarios run, 10 passed and 2 failed, 2 issues filed
Suitability Check refused it before boot, in 2 seconds
Stop after Explore, or Force-stop a running job
Recorded outcomes from real Runs on the platform.
The Suitability Check reads the repo first. An app DeepQA cannot boot is turned away in seconds, before any model is called.
Every Run carries a budget limit you choose. The Run stops itself when it reaches the cap.
Every stage reports live on the timeline, so you always know where a Run is and what it has found.
Stop ends the Run cleanly. Force-stop cancels the job outright when you need it gone now.
AI code review reads your diff and comments on your code. DeepQA uses the product your users get. They catch different failure modes, which is exactly why you want both on every pull request.
Code review tools
DeepQA
The missing layer. Keep your review bot for the diff. DeepQA is what runs after the code looks right: the layer that checks the shipped product still works.
#1 Discover and replay
Point DeepQA at a PR or commit. Agents browse the running app on their own, with no sitemap and no scripts, and turn what they find into a deterministic test Plan that the next Run can reuse.
The Runner clones your repo and starts the app in a fresh sandbox, then destroys it when the Run ends.
Agents browse pages, fill forms, and trigger actions with zero configuration, and the AppMap records everything they reach.
Run #4 on this Plan: 10 passed, 2 failed, 2 issues.
The Plan is prioritized scenarios you can read and diff like code, and the same Plan replays against any SHA.
Reuse the latest Plan for comparable regression coverage, or write a new one when the app has moved on.
#2 Test and audit
Scenarios fan out across parallel agents driving a real browser. Before anything reaches your report, a Critic re-runs every high-impact finding and tries to break it.
/admin/estimates/create
Scenario 10
/admin/payments/create
Scenario 17
/admin/settings/backup
Scenario 31
Three agents work in parallel, and every step is screenshotted.
Clicks, types, uploads, and navigates the real UI, not a simulated DOM.
Screenshots of the moment it broke, console traces, and step-by-step reproduction.
Clicking Create custom assistant crashes the Assistants hub into an error screen
Reproduced live, then reproduced again by hand.
Create Skill form rejects valid input with a vague error
The evidence contradicted the claim that the input was valid. The claim stays visible in the report.
On this Run the Critic reviewed 2 findings, re-verified both live and withdrew 1.
High-impact findings are re-run against the app before they ship as Issues.
False positives are withdrawn on the record, never silently dropped, so you can check the audit instead of trusting it.
#3 Share and choose
Every Run finalizes into a private, evidence-backed report. Publish it and the full record goes live on Explore. The model behind it is your call.
Screenshots are served through signed URLs while the Run is private.
Swap the model profile and the pipeline stays the same.
Finalized Runs are visible to you until you decide otherwise, with screenshots served through signed URLs.
One action puts the full record on the public Explore page, as a link anyone can read.
Issues, screenshots, and the findings the Critic withdrew. Security issues publish as a summary, so a fix can land before the details do.
Gemini on Vertex AI by default, or bring your own key for OpenAI, Anthropic, OpenRouter, or any OpenAI-compatible endpoint. Keys are stored in Secret Manager.
QA runs executed across benchmark and platform campaigns
real applications put under test
confirmed defects in published runs alone
critical vulnerabilities uncovered, incl. auth bypasses
Outperforms the published state of the art on the WebTestBench benchmark: 36.7% vs 26.4% macro F1*
And calibrated, not trigger-happy: 6 criticals on a deliberately buggy app, 0 on a mature product, 2 real ones in between. The finding rate tracks reality.
The running application, not the code in isolation. Agents boot the app behind your PR or commit and test it through a real browser: flows, forms, edge cases, and regressions.
Like a GitHub Actions workflow: automatically on a pull request, or dispatched manually against any PR or any commit. Every Run records the exact SHA it tested and the PR when one exists.
Node and Python fullstack apps that boot without external services. Connect a public GitHub repo and DeepQA takes it from PR to audited report.
No. Each Run executes in an isolated sandbox that is destroyed when the Run finishes. Only the Run's artifacts (report, issues, screenshots) persist, and they stay private unless you publish them.
The Suitability Check reads the repository before anything boots. Stacks DeepQA cannot start, such as an app that needs external services it has no access to, are turned away in seconds, and a rejected Run costs nothing.
DeepQA is in early access, so we onboard teams directly with pricing matched to usage. Spend is not open-ended: every Run carries a budget cap you set, the Run hard-stops there, and live cost is visible while it runs.
Connect a repo, dispatch a Run, and read an audited, evidence-backed report the same day.
