QA agents that use your app like a person would.
Verdikt puts agents on real simulators, emulators and browsers. They explore your app, draft the scenarios, run them and judge every criterion against what the screen actually shows.
From a first look to a gated merge. One loop, run by agents on your devices.
Each stage feeds the next. The agents do the walking, the drafting and the re-running; you review what they could not decide.
Explore
An agent walks the app and measures every screen it reaches.
38 screens · 47 findingsDraft
Scenarios drafted from the explorations and your repo.
12 drafts to reviewRun
Agents run them on real devices; known paths replay with no model.
14 scenarios · 3mTriage
Failures are deduplicated, evidenced and synced to your tracker.
2 new → LinearGate
Every pull request is tested on its own build before merge.
verdikt/pr passedEverything a QA team does. With an agent at every step.
Explore, draft, record, run, triage, measure and benchmark, in one calm Mac app.
An agent maps your app, then measures every screen.
Point it at an app or a URL. It taps and clicks through, every new screen joins the map, and each one is captured in light and dark. Findings are measured, not guessed, and kept apart from what the agent judged.
- aContrast, tap targets, accessibility identifiers, overlap, clipping and off-screen elements, with the number and the threshold
- bOne report per app version, compared with the last: what got better, what got worse
- cJudged findings sit beside measured ones, never mixed into the same count
Scenarios drafted from your repo and what the agent already saw.
Verdikt reads your code and past or new explorations, and drafts outcome-based scenarios with a category, a persona and acceptance criteria. You review the drafts, accept what you want and discard the rest.
- aDrafts stream into a preview as the agent reads files and screens
- bDraft from the code, from explorations, or both
- cAccept selected, then run the first suite in one click
Show it once. The agent writes the test.
Record a flow by clicking through a live frame of any app or website. When you stop, an agent turns your steps into a scenario with outcomes to check, not brittle coordinates, and suggests what else to cover.
- aWorks on iOS simulators, Android emulators and web pages
- bSteps become acceptance criteria you can read and edit
- cSuggestions for the cases you didn't record
Every verdict comes with the frames to prove it.
Runs stream live: steps, frames and per-criterion progress. Afterwards, replay the run frame by frame beside the device pane, with expected versus actual, the evidence for each finding and a fix prompt you can hand to a coding agent.
- aEach criterion gets its own verdict and time range
- bScreenshots, accessibility snapshots and step ranges as evidence
- cRecorded runs replay deterministically, with no model, in seconds
Failures become issues, once, and land in your tracker.
Issues are deduplicated per failing criterion across runs, with occurrences and a baseline, actual and diff view. Triage them here or push them to Linear or Jira and keep them in sync.
- aAcknowledge, Resolve, Not a bug or Archive; rulings feed the agent's project memory
- bLinear and Jira sync, with optional auto-create per project
- cPixel diff against the last passing frame
Know which tests you can trust.
The project Health section charts pass rate, runs and findings by severity, and lists the unstable and slowest scenarios, so flaky tests get fixed instead of ignored.
- aEvery scenario is new, stable, flaky or failing, from its last outcomes
- bOutcome sparklines for each unstable scenario
- cThe slowest scenarios, ranked
Benchmark the agent before you trust its verdicts.
Freeze a finished run as a golden, mark each recorded action correct or incorrect, and score agents and models against it. A live benchmark against an app with known bugs measures recall, false positives, cost and time.
- aAgreement per model lane, with every disagreement listed
- bMix model backends: Claude Code, Codex, Gemini, Qwen, or an API
- cRepeatable, cheap evals on frozen screens
Schedules and alerts, so nobody has to remember.
Run the suite on a cron in your timezone against any target, environment, build and device. Results go to Slack or any webhook, and every run shows whether it came from a person, a schedule or CI.
- aCron presets or custom, “Run now” any time
- bSlack and JSON webhooks for run_completed, run_failed and issue_opened
- cDelivery log and a Send test button
Run on real phones in the cloud.
Connect your BrowserStack or Sauce Labs account and pick a real phone, or “Any Google Pixel” and let your plan choose. The run notes what the provider handed out, and you can watch it live on the provider while it goes. Web targets run on BrowserStack's desktop browsers too.
- aReal Android phones and iPhones next to your simulators; iPhones need a signed .ipa
- bWeb on BrowserStack's Chrome, Edge, Firefox and Safari; Sauce Labs runs phones only
- cParallel sessions capped by your plan, with device-minutes per provider on the Workers page
Built for suites you keep for years.
- v7Edited criteriaRestore
- v6Restored v4Restore
- v5Revised by the agentRestore
- v4Accepted draftRestore
Scenarios, versioned
Outcome-based scenarios on a canvas, with every edit kept. See the history and restore any version.
Hardening
Criteria the agent keeps passing get a deterministic check, proven on past frames. Flaky scenarios are quarantined until they pass cleanly again.
Budgets
Monthly caps on agent spend in dollars or tokens, per workspace, project or profile. Subscription or API keys, mixed per lane.
Workers
Local Mac worker nodes advertise their simulators, emulators and Chromium, and pick up queued runs.
One agent. Web, iOS and Android.
The same tools drive a browser page, an iOS simulator or an Android emulator, so one scenario reads the same everywhere.
Web
Chromium through Playwright. The page becomes an accessibility tree the agent reads, plus console errors and failed requests since the last screen.
- 1280×800 or 390×844
- Console + network
- Preview URLs
iOS
Real iOS simulators driven over idb. Builds from your repo with xcodebuild, or an .app you point it at, installed before every run.
- Simulators
- Light + dark
- Accessibility tree
Android
Emulators and devices over uiautomator2 and adb. The worker boots the AVD you choose on demand and installs the .apk.
- Emulators (AVD)
- Gradle builds
- uiautomator2
Every pull request, tested on its own build.
A GitHub Actions workflow runs your scenarios against each PR and posts a verdikt/pr status. Make it required, and regressions stop at review.
- 01
A pull request opens
A GitHub Actions job on your self-hosted Mac runner reads the event: head, base, the diff.
- 02
Its own build
The PR's head is built (or its preview URL used) and installed on the simulator, emulator or browser.
- 03
Re-judge what changed, replay the rest
Scenarios the diff touches go to the agent; everything else replays its recorded trace with no model.
- 04
Compared with main
Only new regressions fail the check. Failures that already exist on main don't block the merge.
- 05
Status and one sticky comment
The verdikt/pr status lands on the commit, and one comment on the PR says what ran and why.
- Building a1b2c3d on this Mac
- 4 scenarios touched by the diff → agent
- 10 scenarios replayed, no model
- Compared with main: 0 new regressions
$ uv run python -m verdikt.pr run \
--project shop --target-kind ios \
--event "$GITHUB_EVENT_PATH"Your app, your Mac, your data.
There is no Verdikt cloud in the loop. Runs, screenshots and reports stay on your disk.
- verdikt.sqliteeverything, one file
- qa-runs/1280 runs
- storage/
- logs/
- mcp.json
No account
No signup, no login. Open the app and you're on the setup check.
Your disk
Runs, evidence and settings live in one SQLite file and a folder you own.
Your model
Claude Code or Codex on your subscription, an Anthropic or OpenAI-compatible API key, or a local model through Ollama, LM Studio or vLLM.
Your devices
Simulators, emulators and Chromium on your Mac. Nothing is uploaded to a device farm.
Agents that have to show their work do better work.
Verdikt's verdicts rest on a method we measured on two public phone-agent benchmarks: paired statistics, a replicate run, and every trajectory published.
iOSWorld tasks fully passed, same agent with and without the method
in a second, independent run of the same configuration
multi-app tasks, where agents used to skip sub-goals
AndroidWorld, averaged over three suite seeds
- 01The agent writes down every obligation in the goal before it acts: each change to make, each fact to report.
- 02It closes each one with the value it claims and the screen that shows it.
- 03Code, not the model, checks that claim against the screen's accessibility tree, and the run cannot end while anything is open.
- 04Every run leaves a certificate you can re-check, the same evidence Verdikt shows on every verdict.
Proof-Carrying Operation: Device Agents Whose Completion Claims Are Checked Against the Screen
Let the agents take the first pass at QA.
Verdikt is in early access. Tell us about your app and we will set you up: point it at your repo and get your first explored, drafted and judged suite.