SuperPentest is an autonomous AI penetration test for your web app, API or AI agent — it attacks inside a scope you approve, and reports nothing it has not broken into twice over.
No finding, no fee · Authorized targets only · First results in 48 hours
Driving the tools your team already trusts
In their words
“The report only listed things their agent had actually exploited. Our engineers stopped arguing about severity and started fixing.”
“It found a cross-tenant access path a prior scanner had missed, then proved it twice before we saw it. That is the part a questionnaire can’t fake.”
“We ship weekly. Having a run on every release — and only hearing back when something new is proven — fits how we actually work.”
“The report arrived with a replay we could run ourselves. No back-and-forth about whether the finding was real.”
“It mapped a business-logic flaw in our checkout that two prior tests walked straight past. The kind of thing a signature never catches.”
“We needed evidence an auditor would accept, not a severity label. The hash-chained trail did exactly that.”
“Our AI assistant had never been pentested. They proved an indirect injection through a document it read — with a canary we could verify.”
“No finding, no fee turned a budget conversation into a yes. And then they actually found things.”
Attributed by sector and role at our customers’ request. Named references available under NDA during evaluation.
One authorized test, with a report and evidence your auditor accepts — and a retest that proves the fix held.
See pricingPrompt injection, tool-call boundaries and the MCP servers it connects to, tested the way an attacker will.
See AI testingBusiness logic and cross-tenant authorization, proven by reproduction rather than flagged by a pattern.
See deep testingEverything between those two dates goes untested — and that is where incidents actually live. A pentest is a photograph; your attack surface is a film.
SuperPentest closes the gap. You authorize one application and hand over a test account per role. After that the same investigation runs whenever you ask for it, with first results in 48 hours rather than next quarter — and every boundary it respects is enforced by code, not by the model’s judgement.
See how a run is scopedThe same request, sent as each role and tenant you give us, with the answers diffed. That is how a cross-tenant leak surfaces — from a comparison, not a payload.
Coupon reuse, price tampering, skipped checkout steps. We write down what your product promises to enforce, then test each promise as an invariant.
Prompt injection that reaches a tool call, permission boundaries, and the MCP servers your agent connects to. A planted canary proves it acted — it is not a guess.
If the toolbox is unavailable the run is stamped degraded coverage rather than quietly passed as clean. Inconclusive stays inconclusive. No finding never means secure.
A scanner pattern-matches one request. Broken authorization only surfaces when the same request is replayed as every identity and the answers are compared against the rules your app is meant to enforce.
| Request | anonymous | member · north | admin · north | member · south |
|---|---|---|---|---|
| GET /api/invoices/4821 (south) | 401 | 200 ✕ | 403 | 200 |
| PATCH /api/invoices/4821 | 401 | 403 | 403 | 200 |
| GET /api/workspaces/north/members | 401 | 200 | 200 | 403 |
| DELETE /api/workspaces/north/members/7 | 401 | 403 | 204 | 403 |
Behind every line below is a request that actually left the sandbox, against a scope someone signed.
Book a demoPer engagement
Deterministic floors drive the agent across whatever surface your engagement exposes — not a list the model chooses from.
SuperPentest investigates your application in context and proves each result — at a pace and cost a scanner can match but a human team cannot.
| Capability | Traditional scanner | SuperPentest | Human pentest |
|---|---|---|---|
| Business-logic & workflow abuse (coupon reuse, price tamper) | No | Yes | Yes |
| Identity & authorization — cross-tenant IDOR / BOLA | Partial | Yes — replay as each identity | Yes |
| Independent verification before a result is reported | No — pattern match | Yes — clean-session reproduction | Yes |
| Replayable evidence (request + response + control, hash-chained) | Rare | Yes | Varies |
| Scope & rules of engagement enforced deterministically in code | Varies | Yes | Manual |
| Honest coverage — degraded or partial runs surfaced, not hidden | No | Yes | Varies |
| AI agents & MCP — prompt injection that becomes a tool call | No | Yes — tool-call boundaries tested | Specialist only |
| Cost to repeat and retest a fix | Low | Low | High |
Assess SuperPentest on your own application, or read our open, reproducible benchmark — method and scoring published first, results with their evidence as they land.
No long onboarding. Verify, add test accounts, approve the scope — we take it from there.
OnboardingProve the target is yours — ownership is confirmed before any request runs.
So we can replay as each identity and tenant to test authorization.
Rules of engagement — assets, methods and limits — agreed in writing.
Verified findings with replayable evidence your team can act on.
Stress is an authorized resilience experiment, not a flood: narrow budgets, circuit-breaker stop thresholds, and every number reported as measured — including the ones we don't like.
One application or API in scope. Annual billing includes two months free, and your exact scope is quoted in writing before anything runs.
A full Deep assessment with the fix retest included. Meets a yearly pentest requirement.
A broad coverage pass across your attack surface — right for every release.
Multi-round investigation that reasons about your business and your identities.
Authorized, bounded resilience testing. We find the rate limit before a real attacker does — with explicit consent, narrow rails and circuit-breaker stop thresholds. It is never a denial-of-service, and it only runs on a scope you sign separately.
Other tools hand you a blank questionnaire. SuperPentest maps each proven finding to the framework control it breaks — the evidence is the answer, not a spreadsheet you fill in yourself.
Each proven finding carries the exact control it breaks — not a generic risk score.
Run on the days you choose; hear back only when something new is proven.
A shareable, verifiable page for customers and auditors — proof, not a badge.
Authorization is runtime policy. Completion is bounded and honest. The engine decides nothing safety-relevant on its own.
Scope, budget, methods and severity are decided by code and policy — never the model’s call.
Every candidate needs class-appropriate independent reproduction. A 401, 429, 5xx or WAF response is inconclusive, never confirmed.
Pages, responses and callbacks may carry injection. The model never executes target output as directives.
The agent sees identity labels, not raw credentials. Evidence and logs are secret-masked end to end.
Model failure or exhausted budget yields partial or failed — never completed. “No finding” never means “secure”.
Recon discovers assets but never grants permission to test them. Off-domain hits are leads, never auto-authorized.
Runs operate inside a signed rules-of-engagement: ownership is verified first, scope is enforced at egress by code, requests are rate-limited with backoff, stop conditions halt the run, and secrets are redacted from evidence and logs. SuperPentest is not a load generator — resilience testing is a separate, explicitly authorized add-on.
Your application, an approved scope, and test identities — for example a viewer in two different tenants. Point it at staging if you have one, production if you do not. Exact scope is confirmed in writing before anything runs.
A candidate becomes a finding only after it is reproduced independently in a clean session, with a control request showing the expected refusal next to the test request showing the failure. An unreliable response — 401, 429, 5xx or a WAF block — is recorded as inconclusive, never promoted.
For web applications, APIs and the AI inside them, a one-off Deep test is positioned to meet a yearly pentest requirement, with a published coverage map and known gaps. Where you need deep manual work on bespoke components, use the verified evidence to focus that engagement instead of paying for breadth twice.
A scanner flags suspicious patterns. SuperPentest investigates the application in context: which identity acted, what business rule applied, what state changed, and what evidence supports the conclusion. Each result ships with a replayable trace, and anything that cannot be reproduced is dropped rather than reported.
Scope and rules of engagement are enforced in code before any request runs. Reconnaissance can discover assets but never grants permission to test them, and off-domain hits are treated as leads, never auto-authorized.
A shareable page that shows your security posture to a customer or auditor: when you were last tested, that findings were independently verified, and that fixes were retested. You control the branding, can use your own domain, and it stays current on its own — so an outdated snapshot never looks fresh. It is proof you were tested, not a self-reported badge.
You receive a dated scope and rules-of-engagement snapshot, a report with per-finding severity, reproduction and retest status, an audit record per finding, and a shareable trust page. Independence is structural: SuperPentest has no development relationship with your codebase.
I spent years as a platform and DevOps engineer keeping production systems safe. I built SuperPentest so an autonomous pentester runs on the same rails I’d trust in production: strict scope, isolated execution, and evidence you can verify yourself.