Verify AI-written code with an AI QA agent
Your agent writes the code. Prove it works. Coding agents ship features fast and break flows silently. TestAutomate is the verifier layer: it drives a real browser through the thing your agent just built and hands back a graded verdict with screenshots. It runs locally on the Claude Code subscription you already pay for — zero marginal cost.
"Done" according to whom?
Your agent's definition of done: the diff applies, the types check, the unit tests pass. None of that proves the modal opens, the form submits, or the invite email actually goes out. The last mile of agent-written code is the browser — and nobody is checking it.
TestAutomate closes the gap. It drives your real Chrome — real logged-in session, behind VPN and SSO — through the feature, and an AI verifier grades the run pass, fail, or blocked with screenshot evidence. A failure gets re-driven by a stronger model before it is reported, so a red verdict is worth interrupting your flow for.
- Cheap by engineering. Accessibility-tree-first reading instead of screenshot loops, model tiering, and caching keep runs inexpensive. See economics.
- Blocked is not failed. Dev server down or seed data missing returns blocked — your feature is never blamed for a broken environment.
Nothing here asks for a new budget line
$0 marginal cost
Run the agent locally on your existing Claude Code subscription — no extra API spend for local runs. Or bring a team key (Anthropic, Bedrock, Gemini, Groq) and spend passes through at cost with live meters and hard ceilings.
YAML in your repo
Tests are portable, human-readable YAML. Diff them, review them in PRs, grep them. No recorder blobs, no vendor DSL, nothing you cannot take with you.
Self-host everything
The whole stack runs on Node and Postgres, on your infrastructure. Credentials are encrypted with AES-256-GCM; workspaces are multi-tenant. Details on security.
We verify. Your agent fixes. We verify again.
One thing to be clear about: TestAutomate never holds write access to your repository. The loop is designed so your coding agent — not ours — owns every line of code.
We confirm the failure
A failing run is escalated to a stronger model and re-driven. Only a confirmed failure moves forward — flake gets labeled, not filed.
We file the brief
The failure becomes a deduped, confirm-gated Jira bug: repro steps, expected behavior, and screenshots. Everything a fixer needs, human or agent.
Your agent writes the fix
Today you hand the brief to your coding agent yourself. Soon we hand it over directly and your agent opens the PR — the fix is always written by your agent, in your repo, under your review.
comingWe re-verify and close
The fixed build gets re-driven through the same test. A passing re-verify closes the issue. A failing one reopens the conversation with fresh evidence.
Where this is headed — labeled honestly
Verify on every PR
A GitHub Action that runs your verification suite against the preview build, plus blast-radius checks that map which user flows a diff touches. Today, runs are kicked off from your machine or the app.
A tool your agent can call
An MCP server so your coding agent can request a verification mid-task: "check whether the flow I just changed still works" — and get a graded verdict back as a tool result.
Brief-to-PR, automatically
Confirmed failure briefs delivered straight to your coding agent, which opens the fix PR; we re-verify the result. We orchestrate; we never commit.
Ship agent-written code you can actually trust
Install locally, point it at your dev build, and get your first graded verdict before your next standup.