The coding agents got faster. Nobody took over the checking: TestSprite 4.0 treats your spec as the answer key and writes 29 end-to-end tests for a single merge
TL;DR
On November 20, 2026, Seattle-based TestSprite shipped version 4.0. It is not another code-writing tool. It is a testing agent aimed at the gap that opened up when teams started shipping software with AI coding agents.
You describe what the app is supposed to do — in plain language, or by handing over a PRD, a Jira or Linear ticket, a Figma file. The agent opens your running app in a real browser, walks through the flows, writes the tests, runs them, and tells you which failures are real bugs.
The clearest illustration is a demo the company staged on purpose: a tiny online store with a ten-line spec. Two pull requests, each passing its own check, merge cleanly. After the merge, coupons start discounting items that are already on sale. On Black Friday, that is every discounted item in the store discounted twice.
This is worth writing about because it names a very specific hole in 2026: there are plenty of agents that write code, and almost nothing that checks whether the pieces still work once they are combined.
What problem it actually solves
Start with the demo, because it explains the product better than any feature list.
The store needed two features before the holiday sale: coupon codes and sale prices. The spec was ten lines long. Line 4 read: "Items on sale are not eligible for coupons."
- The first pull request added coupons and made them skip any product tagged as on sale. Claude Code's
/verifycommand passed it. - The second pull request added sale prices with the old price crossed out. A crossed-out price already signals "on sale," so this change dropped the tag.
/verifypassed that one too, noting: "Nothing else in the code readsonSale, so removing that flag breaks nothing today." - On that branch, the note was correct. GitHub then merged both with no conflicts, because they never touched the same lines.
The result: the coupon looked for a sale tag and found none. TestSprite had generated 29 tests from that ten-line spec. Before the merge, none of them complained. After the merge, the test named "Do not discount sale items with a coupon" went red, with the exact discrepancy: a $20 mug and a tote marked down from $60 to $40 in the cart, coupon SAVE10 applied. It should have taken $2 off the mug. It took $6 off the whole cart.
Neither single-change check could see this, because neither change was wrong on its own. That is the gap.
The core design decision: the answer key does not come from the code
This is the substantive difference between TestSprite 4.0 and "have the coding agent write some Playwright tests while it is at it."
The company's blog puts it bluntly: if a test is written by reading the code, it takes its expected answer from the code — bugs included. Such a test does not miss the bug; it protects it.
Version 4.0 moves the source of truth to the spec: a PRD, a ticket, a design file, or a few sentences from someone who knows the product. That expectation changes only when a person decides it should.
In practice that means three things:
- Explore before writing. The agent signs itself in (one-time codes included), clicks through the app, and records how it behaves before it writes a single test.
- Ask instead of guessing. Where the spec is silent, it lists its assumptions and waits. In one demo it asked whether totals should be rounded per line or only at the end, noting the two can differ by a cent.
- Classify every failure. Each red result is sorted into a real bug, a broken test, or a broken environment, with what should have happened, what did, and a step-by-step recording.
Test expectations also only change with human approval. If a button moves, the agent updates the steps. If the app stops doing what you asked for, the test fails.
Why this matters now
The change in 2026 is that code volume stopped being the bottleneck.
Claude Code, Codex, Cursor and their peers made writing cheap. AI code review made reading diffs cheap. The step in between — someone actually using the product the way a customer would — did not get cheaper. It got rarer, because teams now believe they have two checks already.
The company's own description of the pattern is blunt: teams ship with a coding agent and an AI reviewer, nobody clicks through the product anymore, and bugs pile up quietly until customers find them all at once.
So the market for this category depends less on how accurate AI testing is and more on how many teams actually run several agents in parallel. More parallelism means more merges, and the merge is the blind spot that per-change checks structurally cannot cover.
How to wire it in: four steps
Step one: start with a single app. Paste the app's address and write a few sentences about what it should do. If you cannot produce a spec, write down the most important business rules first — "items on sale cannot use coupons" beats a hundred UI assertions.
Step two: read the test plan it proposes, line by line. The plan is grouped by what each test covers, and every line is an expectation you can read and edit. Do not skip this. The lines you skip are exactly the ones it cannot judge for you later.
Step three: run once in full before automating anything. Look at the failure classification first. If most failures are "broken environment," your test setup is unstable — fix that. If most are "broken test," your spec is too vague — go back and tighten it.
Step four: connect it to the workflow you already have. There are four entry points: the web chat, an open-source CLI (Apache-2.0, TestSprite/testsprite-cli, 5,212 stars), an IDE plugin over MCP, and automatic testing on GitHub pull requests. The free tier already includes pull-request testing on one repository plus Slack notifications, so begin with that one repo rather than rolling it out everywhere.
Who this is a good fit for
- Teams already shipping business code with Claude Code, Codex or Cursor, merging a dozen pull requests a week, with no systematic regression pass.
- Products that are web apps or APIs and can be opened in a browser. It does not care who wrote the code: Lovable, Bolt, Claude Code, or a room full of engineers.
- Products with explicit business rules worth defending — pricing, permissions, checkout, approval flows — that already live in a requirements document.
- Teams that want tests humans can read: every test it writes is also code you can read and edit.
Who this is not a good fit for
- Native mobile apps. Its territory is web apps and APIs reachable from a browser. Do not expect it to cover iOS or Android clients.
- Products where nobody can articulate the spec. The answer key comes from the spec. If the spec is vague, the agent can only surface its assumptions and ask you, and a human still has to decide.
- Anyone who wants to hand over judgment entirely. The design requires human approval for expectation changes. The more you let go, the less it can verify beyond what you already wrote down.
- Teams needing private deployment on a tight budget. Single-tenant deployment, SSO, SCIM and audit logs all sit in Enterprise, which starts at $199/month for 10 seats.
- Anyone treating "90% lower testing costs" as a commitment. That figure is the vendor's own and is flagged as such in third-party coverage. Actual savings depend on how much repetitive regression work you have.
Pricing: five tiers, split by environments and history
- Free: $0, 150 credits per month, one environment, 30 days of run history, including agent chat, the CLI, the IDE plugin, pull-request testing on one repository, and Slack notifications.
- Starter: free for the first month, then $19/month, 400 credits, one environment, pull-request testing on three repositories.
- Standard: $39/month, 800 credits, three environments, 90 days of history, Jira and Linear integrations.
- Pro: $69/month, 1,600 credits, unlimited environments and history, the most capable agent model, agent memory across the workspace.
- Enterprise: from $199/month (10 seats minimum), from 5,000 credits, single-tenant deployment, SSO/SCIM/audit logs, custom integrations.
Annual billing takes 35% off. It is also sold on AWS Marketplace, so existing cloud commitments can be used to pay for it.
One boundary worth noting: agent memory is tiered. Standard gives memory per project; only Pro gives memory across the whole workspace. If your app spans several projects, whether the memory connects is a real difference in daily use.
Pitfalls
- Do not expect it to define "correct" for you. It verifies the expectations you wrote down. Rules missing from the spec will not be caught; the agent will only ask.
- Do not roll it out to every repository on day one. The free tier gives 150 credits and one environment; a full first run can burn through that quickly. Prove it on one critical repo.
- Credits are consumed by test runs, not seats. More detailed tests cost more per run; watch the burn rate during heavy merge periods.
- Review the failure classification by hand for the first week. The costs are asymmetric: a test wrongly called broken wastes ten minutes, a real bug wrongly dismissed can reach production.
- It is not a replacement for code review. Code review judges whether a diff is sound; this judges whether the product still works. Neither substitutes for the other.
- A 5,212-star CLI is not an open-source product. The command-line tool is open; the cloud agent and the browser farm remain a closed service.
Next step: try it on one project
If you only want to test whether it is worth it: pick one small project where a recent merge caused a problem, paste the address, write five business rules, and let it run once. See whether it reproduces the bug you found by hand last week. If it does, then talk about wiring it into pull requests.
Sources
- TestSprite official blog (Nov 20, 2026): https://www.testsprite.com/blog/introducing-testsprite-4-0
- TestSprite pricing: https://www.testsprite.com/pricing
- TestSprite CLI repository (Apache-2.0): https://github.com/TestSprite/testsprite-cli
- AccessNewswire release (Nov 20, 2026): https://www.accessnewswire.com/newsroom/en/computers-technology-and-internet/testsprite-4.0-launches-an-independent-testing-agent-to-verify-wh-1254595
- Lucidwire report (Nov 20, 2026): https://lucidwire.in/en/article/testsprite-4-0-agentic-testing-launch
- CrazycodersLab report (Nov 20, 2026): https://crazycoderslab.com/testsprite-4-0-ai-testing-agent-coding-agents-spec-regression-pull-requests-2026/
This article is compiled from multiple media reports, together with the company's official blog and pricing page. Figures such as "90% lower testing costs" and "150,000 developers" are the vendor's own claims and have not been independently verified.
Sources
- https://www.testsprite.com/blog/introducing-testsprite-4-0
- https://www.testsprite.com/pricing
- https://github.com/TestSprite/testsprite-cli
- https://www.accessnewswire.com/newsroom/en/computers-technology-and-internet/testsprite-4.0-launches-an-independent-testing-agent-to-verify-wh-1254595
- https://lucidwire.in/en/article/testsprite-4-0-agentic-testing-launch