Every finding is urgent. That is the problem this solves.
CVSS scores the vulnerability. It has never seen your environment: which asset it sits on, whether anything can reach it, or what it would cost you specifically.
AIPTx scores the situation: severity, exposure and asset criticality, weighted into a single number you can inspect and argue with.
Scope verified before any test runs · Destructive actions off by default

- 100-point
- Risk score, weights published
- CVSS 3.1
- Vector on every finding
- 4 factors
- Severity, exposure, asset criticality, volume
Severity is not a plan
A severity label sorts findings. It does not sequence work.
Sort four hundred findings by CVSS and you get sixty criticals, which is not a prioritised list, it is the same problem in a different order. Some of those sixty sit on an internal tool three people use. Some sit on the authenticated path to your customer data. CVSS scored them identically because CVSS is a property of the vulnerability, not of your situation.
Meanwhile the finding that should be at the top is often a medium. It is a medium because in the abstract it is a medium. On a production system, reachable without authentication, one hop from a credential store, it is the first thing anyone should fix.
CVSS is the starting point, not the answer
Every AIPTx finding carries a CVSS 3.1 score and the full vector string. That is deliberate. CVSS is the shared language of vulnerability severity and abandoning it would make findings harder to compare, not easier to act on.
What CVSS gives you
A consistent, portable, independently-defined measure of how bad a vulnerability is in the abstract. Critical 9.0–10.0, High 7.0–8.9, Medium 4.0–6.9, Low 0.1–3.9. Everyone in security understands it, every tool emits it, and every auditor accepts it.
What CVSS cannot give you
Any knowledge of your environment. The base score is calculated once, by someone who has never seen your architecture, and it is identical for every organisation on earth running the affected component.
That is not a flaw in CVSS
It is the design: a portable score has to be context-free to stay portable. The mistake is treating a deliberately context-free number as a remediation order.
What AIPTx does with it
The CVSS score and vector travel with every finding, unmodified, so your reports, your compliance evidence and your existing tooling all keep working. Contextual weighting is applied on top, as a separate layer, and never by quietly editing the base score.
The same vulnerability is not the same risk twice
Two systems, the same CVE, the same CVSS score. One is a staging instance behind a VPN with test data in it. The other is production, internet-facing, holding customer records. Treating those as one priority is how remediation capacity gets spent in the wrong place. AIPTx weights four factors into a single 100-point score. The weights are published, which means you can inspect them, reproduce the arithmetic, and disagree with the result on specific grounds rather than on principle.
- Critical findings: up to 40 points
- The heaviest weighting, because a confirmed critical is the closest thing to a decision the model makes on its own.
- High findings: up to 25 points
- Volume matters here as well as severity. A system with fifteen highs is in a different condition from one with two, even where no single finding is worse.
- Exposure level: up to 8 points
- How reachable the affected surface is. Internet-facing and unauthenticated is a different proposition from internal, behind a VPN, and requiring a privileged session.
- Asset criticality: up to 5 points
- What the affected system is worth to you. This is the factor only you can supply, and the one that most changes the answer.
A production application · 78 / 100
Every factor, its contribution, and the total
- Critical findings40 / 40
- High findings25 / 25
- Exposure level8 / 8
- Asset criticality5 / 5
- Contextual risk score78 / 100 · High
A risk score you cannot decompose is a risk score you cannot defend in a room with engineering leadership.
Asset criticality is your input, not our guess
No scanner can know that the low-traffic internal service is the one holding your payment reconciliation logic. Asset criticality is the factor you set, and setting it honestly is what makes the rest of the model useful.
Most teams find this is the highest-leverage twenty minutes they spend on the platform.
Proven beats predicted
Most risk models estimate exploitability. They look at attack complexity, required privileges, whether public exploit code exists, and produce a probability. AIPTx is in an unusual position here. It does not have to estimate whether a finding is exploitable, because it tried.
- The strongest exploitability signal is an exploit
- Every AIPTx finding that reaches confirmed status did so because the attack was performed and the evidence captured: the request, the response, and a reproducible curl command that demonstrates it. That is a categorically different input from a predicted likelihood. A model guessing at exploitability is doing inference. A captured request/response pair is observation.
- What this changes for prioritisation
- The usual triage question (is this actually exploitable in our environment?) is answered before the finding arrives. Your team is not sequencing work by estimated probability. They are sequencing work that is already known to be possible.
- Where prediction still matters
- Not everything can be safely exploited. A finding that would require destructive action to prove is reported without that proof, and for those, conventional exploitability reasoning still applies: known exploit availability, attack complexity, required privileges.
- Proven and predicted are kept apart
- The distinction is worth being clear about. Proven and predicted are different confidence levels, and a risk model that blends them into one number without saying so is hiding the thing you most need to know.
An artefact, or an estimate
One confirmed finding, beside the conventional alternative
- HTTP requestCaptured
- HTTP responseCaptured
- Reproduction commandcurl, runs as issued
- AIPTx exploitabilityProven: the attack ran
- Conventional modelPredicted likelihood 0.8
- Evidence behind that figureNone attached
A predicted exploitability of 0.8 and a captured HTTP response proving the exploit are not the same evidence, and should never produce the same score.
What it costs if this one is used
Technical severity and business impact are related, but they are not the same measurement, and the gap between them is where most remediation ordering goes wrong.
Data reach
What the affected component can access determines most of the real cost. Customer records, payment data, credentials, health information and internal business logic each carry a different consequence, and a vulnerability's impact is largely inherited from what sits behind it.
Operational disruption
Some vulnerabilities leak data. Others stop the business. Availability impact on a revenue-carrying path is a different conversation from a confidentiality issue on an internal reporting tool, and the two should not be competing for the same slot in a queue on the strength of a matching CVSS score.
Trust and disclosure
The cost of a breach is rarely bounded by the technical remediation. Notification obligations, customer communication, contractual commitments and the security questionnaire every enterprise customer will send afterwards all follow from a single finding being used.
Remediation cost
The other side of the ledger, and the one most risk models ignore entirely. A configuration change is an afternoon. A schema change to fix an authorisation model is a quarter. Two findings of equal risk and unequal cost do not belong in the same position in the queue, and pretending otherwise is why security backlogs stall.
Asset criticality, again
This is the factor that ties the section together, and the reason the model asks you for it. Everything above is a way of describing what an asset is worth. The score can weight it. Only you can set it.
Regulatory exposure
A finding that touches PCI DSS scope, HIPAA-covered data or GDPR-relevant personal data carries consequences beyond the technical fix. AIPTx maps findings to PCI DSS, SOC 2, ISO 27001, HIPAA, GDPR, NIST and CIS controls, so the compliance dimension is visible while you are prioritising rather than discovered during an audit.
- PCI DSS
- SOC 2
- ISO 27001
- HIPAA
- GDPR
- NIST
- CIS
From raw findings to a queue with owners
Scoring is only useful if it ends in someone doing something. This is the path a finding takes from detection to closed.
- 01
Score
Severity, exposure and asset criticality are weighted into the 100-point score. CVSS 3.1 travels alongside, unmodified.
0–100 - 02
Cluster
Findings sharing a root cause are grouped. Eleven instances of one missing authorisation check become one piece of work with eleven locations, rather than eleven tickets that three engineers investigate separately.
Root cause - 03
Rank
The queue orders top-down. Not by severity label, and not by discovery date, by the score, with the factor breakdown visible on each item so the ordering can be questioned on specifics.
Top-down - 04
Route
Findings reach the systems where work actually happens: Jira and Linear as tickets with severity mapped to your priority scheme, Slack and Microsoft Teams for alerting, SARIF into the developer's pull request and editor.
Ticket and PR - 05
Remediate
Each finding carries a remediation object: a summary, a code example showing the vulnerable pattern and the secure one side by side, and references. The engineer receives the fix in the language they are working in, not a link to a generic advisory they have to translate.
Fix included - 06
Resolve
Every finding carries a status: open, fixed, accepted, or false_positive. Status changes are attributed and timestamped, with notes attached.
AttributedThe accepted state is the one worth calling out. Some risk is accepted deliberately, and that is a legitimate outcome, but it should be a recorded decision with a name against it, not a finding that quietly stops being discussed. When an auditor asks why a High from March is still open, "accepted, by this person, for this reason, on this date" is an answer.
A score that never moves is a report
Prioritisation is only worth doing if the queue empties. Two mechanisms make that measurable.
Fixes are verified, not asserted
A finding moves to fixed when the exploit stops working, not when someone marks it done. Retest re-runs the specific attack against the changed code.
The score is comparable over time
Reports include trend comparison against previous scans, so the 100-point score is a tracked measurement rather than a snapshot. "Our risk score went from 78 to 41 across two quarters, and here is the finding-level detail behind it" is a sentence that works in a board pack, and it is the reason to keep the scoring model consistent rather than tuning it.
FAQs
AI Risk Engine questions
How is the risk score calculated?
On a 100-point scale from four weighted factors: critical findings contribute up to 40 points, high findings up to 25, exposure level up to 8, and asset criticality up to 5. Every report shows the breakdown, so a score of 78/100 arrives with the arithmetic that produced it. The weights are published deliberately. A score you cannot decompose is a score you cannot defend to engineering.
Do you replace CVSS?
No. Every finding carries its CVSS 3.1 score and full vector string, unmodified. Contextual weighting is applied as a separate layer on top, never by editing the base score. You always see both numbers, which is what keeps the finding portable to your other tooling and acceptable to an auditor.
Why does the same finding score differently?
Because exposure and asset criticality differ. An internet-facing production system holding customer data and an internal staging instance with test data are not the same risk, even running the identical vulnerable component. CVSS scores them identically by design, because a portable score has to be context-free. Prioritisation cannot afford to be.
Who decides asset criticality?
You do. No scanner can know which of your systems matters most. The low-traffic internal service holding payment reconciliation logic looks unremarkable from outside. Setting criticality accurately is the highest-leverage configuration on the platform, because it is the input that most changes the ordering.
How does exploitability factor in?
Findings that reach confirmed status were exploited, with the request, response and a reproducible curl command captured. That is observation rather than estimation, and it removes the usual triage question of whether something is genuinely exploitable in your environment. Where a finding cannot be safely exploited, it is reported without that proof, and proven and predicted are kept distinct rather than blended into one number.
What happens to findings we decide not to fix?
They move to accepted, with the person, the date and the reason recorded. Accepting risk is a legitimate decision; the platform's job is to make sure it was a decision rather than a finding that quietly stopped being discussed. When an audit asks why a High from March is still open, the record is the answer.
How do we know remediation is actually working?
Findings close only when the exploit stops working on retest, and reports carry trend comparison against previous assessments. That makes the 100-point score a tracked measurement over time rather than a snapshot, which is what turns it into something reportable to a board.
How often is the score recalculated?
It moves when the evidence does. A completed assessment produces the score, and a retest that closes a finding changes it, which is what makes the trend comparison between reports meaningful. Between runs it is a measurement with a date on it rather than a live gauge, and treating it as the latter is how a number ends up on a dashboard describing an application that has since shipped four times.
Is the scoring a black box?
No, and this is the reason the weights are published rather than described as proprietary. You can see each factor, its contribution and the resulting total. Where the model is wrong for your environment, you can identify which factor is wrong and say so specifically, which is more useful than a number nobody can interrogate.
Can we change the weights to match our own risk appetite?
Yes. The four factors and their weights are configurable per environment, and a security team that treats a regulated database as categorically more important than an internal tool should say so rather than argue with the default. Two guardrails: a change re-scores the whole backlog rather than only new findings, so the queue stays internally consistent, and the previous weighting is kept alongside it, so a finding that moved can be shown to have moved because the policy changed and not because the evidence did.
The rest of the platform
Scoring is one view of one engine. Each capability feeds the next.
Autonomous Pentesting
AI agents that map, exploit and prove. The exploitation evidence is what lets this page rank by proven rather than predicted.
See how testing runsVulnerability Discovery
Seven vulnerability classes, 245+ tests, every finding classified against CWE, OWASP and CVSS 3.1.
See what gets foundAttack Chain Analysis
Reach is the factor severity models miss. Four mediums in the right order is a breach. This is the view that shows which four.
See the attack pathsSee your findings in priority order
Run an assessment and get a scored, ranked queue with the factor breakdown attached to every item. No credit card required.
Scope verified before any test runs · Destructive actions off by default