![]()
The New Agent Checks Every Change Against What the App Should Do, and Scores 94% on TestSprite’s Internal Bug-Finding Benchmark, Against 86% for Claude Code and Codex
SEATTLE, WA / ACCESS Newswire / November 20, 2026 / TestSprite today launched TestSprite 4.0, an independent testing agent that checks software separately from the developer or coding agent that wrote it. Teams describe what their product should do. TestSprite 4.0 then tests every change against that description, across the frontend and backend, in real browsers. A moved button won’t break its tests, because the agent updates its own steps as the interface changes. A test fails only when the product stops doing what the team asked for.

The launch comes as engineering leaders debate how to check the code that AI agents write. At the recent AI Engineer Code Summit, Lauren Tan, who builds Grok Bot and Cursor at SpaceX Super Intelligence (SpaceXSI), argued that teams should “review proof, not code.” Rather than read every line, she said, teams should look for evidence that the software works. Her post sharing the talk drew more than 2.2 million views. Two days later, Anthropic’s Claude Code team described the verification layer that lets it hand most of its coding to Claude. Neither approach asks the agent to grade its own work. TestSprite 4.0 is an independent agent that runs the real product and checks it.
The Verification Gap
The volume of AI-written code is growing faster than teams can verify it:
- SlashData’s 32nd Developer Survey found that 81% of professional developers say AI reduces repetitive work but increases the need for review and validation.
- A Harvard working paper covering 655 firms found that after adopting coding agents, the number of proposed code changes rose 35.7%, while the time reviewers took to approve each one rose 56.1%.
“Coding agents made writing code cheap and verifying it expensive,” said Yunhao Jiao, co-founder and CEO of TestSprite. “The agent that wrote the code shouldn’t be the only one checking it. TestSprite 4.0 remembers what your app should do and checks all of it on every change, so teams can keep shipping as fast as they build.”
A Real Agent, From Brief to Verdict
TestSprite 4.0 is an agent, not a test generator. A team briefs it the way it would brief a colleague, with a few plain sentences, a product spec, a Jira or Linear ticket or a code repository, and the agent does the rest:
- It explores first. Before writing a test, it opens the running app, maps the flows and plans what to cover. It signs itself in, one-time codes included.
- It asks instead of guessing. When the brief doesn’t cover something, it lists its assumptions and asks.
- It remembers. It keeps a record of what the app should do and carries it from run to run, so every later change is checked against the same expectations.
- It runs the tests itself, in real browsers, 100 or more at once, and records every step.
- It tells real bugs from noise. Each failure is sorted into a real bug, a test problem or an environment problem, with what should have happened, what did happen and the recording.
- It maintains the suite. Tests a team approves become its regression suite. The agent updates the steps as the interface changes, and a test’s expectations change only with the team’s approval.
When a pull request is opened, by a person or by a coding agent, TestSprite 4.0 runs the suite and posts the result as a GitHub status check. A failing test can open a Linear or Jira ticket and post to the team’s Slack channel. From the terminal, the open-source TestSprite CLI lets a coding agent such as Claude Code or Codex hand its work to TestSprite, including for an app running on the developer’s own machine. Teams already on TestSprite keep their existing test lists, schedules and integrations.

TestSprite Runs on TestSprite
TestSprite’s engineers build the product with coding agents such as Claude Code and Codex, so they need to check agent-written code just as their customers do. TestSprite 4.0 started as the team’s answer to that problem, and the team runs it on TestSprite’s releases. Before this launch, the agent caught 16 real issues in new features, from usability problems to functional bugs, before any customer saw them.
Benchmark and Cost
On TestSprite’s internal bug-finding benchmark, TestSprite 4.0 scored 94%, against 86% for both Claude Code (Opus 5.5) and Codex (GPT-6.1 Sol). It is also inexpensive to run: generating and running 200 frontend integration tests cost $4.60, at 96.5% test-execution accuracy.
Developers have installed TestSprite’s Model Context Protocol (MCP) server and command-line tool more than 600,000 times since August 2025, and the open-source CLI has earned more than 5,000 GitHub stars since June 2026.
Availability
TestSprite 4.0 is available today at testsprite.com, with a free tier. It works on any web app or API, regardless of who wrote the code and with the AI coding tools teams already use, including Claude Code, Codex and Cursor, through its MCP server and open-source CLI. TestSprite is also available on AWS Marketplace. Watch the TestSprite 4.0 launch video here.
About TestSprite
Based in Seattle, TestSprite is the verification backbone for the agentic software era. Its independent testing agent checks every change against what the software should do, so teams can ship at agent speed. TestSprite runs wherever code is written and reviewed, from the IDE to the coding agent’s terminal to every pull request. More than 150,000 developers and 50,000 teams have built with TestSprite. Learn more at testsprite.com.
Editor’s note: Additional product screenshots and video are available upon request.
Media Contact:
Carmen Hughes
Ignite X
650.576.6444
carmen@ignitepr.com
SOURCE: TestSprite, Inc.
Related Documents:
- testsprite-40-internal-benchmark-results-94-vs-86-for-claude-code-and-codex
- testsprite-40-failure-report-showing-expected-vs-actual-results
View the original press release on ACCESS Newswire
Media gallery


