Agentic Code Review

Your code was written for a slower world.

AI attackers turn three small flaws into one breach. We find the chain first.

A general-purpose AI tool finds some of the vulnerabilities in your code. Our specialist AI agents are built for specific languages and vulnerability types, so they go deeper and trace how small weaknesses chain into a real compromise. Every finding is checked by an independent AI verifier before you see it, with a record that holds up after an incident and in an audit.

01

Discover.

We map your code and agree with you what counts as a finding for this system.

02

Hunt.

Specialist AI agents, built for specific languages and vulnerability types, go deeper than a general-purpose tool.

03

Verify.

Every finding checked by an independent AI verifier, ranked and recorded. Fixing is your choice: your team, anyone you pick, or our engineers.

Why this matters now

The assumption your security was built on no longer holds.

Most security programs rest on a quiet assumption: finding a serious flaw takes a skilled person a lot of time. A scanner catches the known patterns, a pen test runs once a year, and the rest was covered by how slow and expensive the search was. AI has removed that cost for attackers.

The code nobody has read in years

Every organization has one: a system that has run for 15 years, still faces the internet, and hasn't had a line-by-line review since the people who built it moved on. Reading all of it was never worth a skilled person's time. For an attacker with AI, it now is.

Attackers no longer need time

In May 2026 the UK AI Security Institute reported that the length of cyber tasks frontier AI can complete on its own was doubling every 4.7 months, and that Claude Mythos Preview had outpaced even that. The latest version completed a 32-step simulated corporate network attack in six of ten attempts. The distance between a flaw existing and a flaw being used is shrinking fast.

More findings than anyone can decide on

More findings don't make anyone safer on their own. Each one needs a decision about whether it matters, whether to fix it first, or whether to dismiss it, and no team can make those calls by hand at AI scale.

Regulators now expect proof

Under the EU Cyber Resilience Act (CRA), failing the essential cybersecurity requirements can cost up to €15 million or 2.5% of worldwide turnover. Under the NIS2 Directive, essential entities face maximum fines of at least €10 million or 2% of turnover, and management can be held personally liable. The Digital Operational Resilience Act (DORA) sets the same expectation for financial services. "We didn't know" is no longer a defense.

Recent AI-driven security incidents

Updated monthly.

  1. September 2026 An autonomous AI agent got into non-public files on Australia's Medicare statistics portal and wrote files to an internal server, the prime minister said. No personal data is believed to have been accessed. Source →
  2. August 2026 Asked to book a gym class, an AI assistant found a flaw in the booking software and used it to book months ahead and push someone else off the waiting list. It was Australia's first known autonomous cyberattack. Source →
  3. July 2026 Attackers used an open-source AI agent, running unattended, to automate work inside systems at Thailand's Ministry of Finance, researchers reported. The ministry has not confirmed a breach. Source →

Specialist agents

Trained to hunt, not just to scan.

This isn't one AI prompt pointed at your code. It's a harness: 13 specialist agents, repeated passes, an independent AI verifier, fixed-rule recording and a pattern library that grows with every engagement, all working together.

Each of our 13 specialist AI agents focuses on one class of vulnerability and works from Nortal's pattern library. The library grows with every engagement, but only as general vulnerability patterns. Your code is never added to it, and nothing that identifies you or your systems carries over to another client. Every finding is then checked by an independent AI verifier and ranked by how an attacker could reach it, so you get a list you can act on, not one you have to sort through.

team working on laptop
95%

Nortal specialist agents

Share of documented vulnerabilities found in 20 public code repositories. All 13 agents read the whole codebase once, then again: 70% were found on the first read, 95% after nine.

55%

Nearest frontier lab's free AI code reviewer

0%

Free rule-based scanner

Measured against 20 public code repositories with documented vulnerabilities and scored against a known-answer key, our specialist agents found 70% of them in a single pass, 85% in two, about 90% in four and 95% at nine. The nearest frontier lab's free AI code reviewer reached 55%. The free rule-based scanner, which the pipeline itself uses as a seed for hints, found none. These are relative figures on a public benchmark that the models may have seen in training, so they are reported as a conservative floor rather than a guarantee on a given codebase.

Liability doesn't come from the findings. It comes from the decisions about them.

After an incident

A flaw that was flagged and dismissed without a record proves you knew.

In an audit

A finding you can't trace can't be defended.

Audit-grade findings

Found, verified and on record.

We find the vulnerabilities that matter in your code, including the ones general tools miss. Each one arrives verified, ranked and ready to act on, so you can move at AI speed without taking on AI-scale liability.

01
Found

Found, not just flagged

Our 13 specialist AI agents each hunt for one class of vulnerability, reading the whole codebase for meaning, not just patterns. They follow data across files, look at the logic underneath the code, and trace how small weaknesses chain into the path an attacker would take. Several passes run, and the results are merged. Weaknesses an attacker can't reach today are still recorded and rated, because a new feature or a changed configuration can expose them tomorrow.

02
Verified

Verified before you see it

An independent AI verifier, separate from the agents that found it, checks every finding against the code and gives it a verdict. Nothing is quietly dropped, and the reasoning stays with it.

03
Prioritized

Ranked by reach

Findings are ordered by whether an attacker can reach them and which ones combine into a compromise, not by a generic severity score.

04
Audit-grade

A record of every decision

One formal record per finding, pinned to the model and prompt versions that produced it. Reports for your board, your engineers and your auditor all come from it.

Every finding comes with a recommended fix, so your own engineers, or anyone you choose, can close it. If you'd rather we did it, our engineers can take it on as a next step, delivered as pull requests with test cases. Run it once, or keep it running inside your CI/CD pipeline as your code changes.

Two things make it work.

Reachable, not just flagged

A scanner checks each line against known patterns. It can't see that a permission is fine on its own and wrong once you know who calls that function. Our specialist agents follow data across files, connect small weaknesses into the path an attacker would take, and rate each finding by whether it can actually be reached.

So your team fixes what can be reached first, not what scores highest.

Auditable, not a black box

AI finds the vulnerabilities. Standard code records them. The finding layer is AI, so it improves as the models do. The recording layer follows fixed rules: the same inputs always produce the same evidence pack, and no run is ever overwritten. Each record is tied to the model and prompt versions that produced it, with a fingerprint of every file that was read. That means every conclusion can be traced and audited.

"We used AI" is not an answer. A traceable method and a versioned record are.

One codebase at work

What happens when we open up one of your systems

Picture a payments platform that has run for 15 years, and nobody who wrote the first version still works there. This example is illustrative. The walkthrough advances on its own, or click through.

We agree the rules before we read a line

We take the code where it sits. It runs where you need it, from your own cloud to fully offline. We only ever read it. Together we write a threat model that sets what counts as a finding for this system.

No code is touched until the legal and data terms are signed.

Read-only repository access Threat model Architecture docs Past pen test reports Existing scanner output We take the code where it sits

Our 13 specialist AI agents read the code

The assessment is tuned to the languages your code is written in. Each AI agent looks for one class of vulnerability, in the code and in the logic underneath it, and checks against our pattern library, with a rule-based scanner feeding it hints. Every agent holds read-only tools and a guard on which files it may open. Several passes run, and the results are merged.

Each pass catches something the last one missed.

Injection agent
Access control agent
Path traversal agent
Scanner hints (seed)

A second opinion that hasn't heard the first

Plain code merges the duplicates. An independent AI verifier gets the findings but never the agents' reasoning, checks each one against the code's logic and reaches a verdict. Then a sequencing analysis shows which findings combine: this one, plus this one, plus this one, equals compromise.

Nothing is thrown away. Our security lead reviews the result and signs it.

Confirmed
A vulnerability, traced to the line
Likely
Probably a vulnerability, flagged for a closer look
Likely not
Probably safe, still on the record
Not a vulnerability
Ruled out, with the reasoning kept

Evidence that says the same thing every time

Deterministic code, not AI, turns the findings into an evidence pack: one formal record per finding, pinned to the model and prompt versions that produced it, with a SHA-256 hash of every source file read. Secrets are masked before they reach a record. Every report you see is rendered from that pack.

If you want us to fix, our engineers deliver pull requests with test cases. Or your team takes the recommended fixes from here.

  1. 01One formal record per finding
  2. 02Reproduction steps and proposed fix
  3. 03Pinned to model and prompt versions
  4. 04Fixes as pull requests, if you want them

Where the machines work and people sign

Each phase shows who leads the work and the gate it has to clear before the next one starts. Nobody skips the gate.

01

Agree terms

Data handling and scope signed before we access any code.

Led by people · gate: legal sign-off, both sides
02

Threat model

We agree with you what counts as a finding for this system.

Led by our security lead · gate: threat model agreed with you
03

Hunt

13 specialist AI agents, several passes, read-only access.

Led by AI, steered by our security specialists · gate: duplicates merged by code
04

Adjudicate

An independent AI verifier argues each finding both ways.

Led by AI · gate: every finding labeled, none discarded
05

Record

Deterministic evidence pack, one record per finding, with our security lead accountable for the results.

Led by code · gate: evidence pack complete
06

Fix

Pull requests with test cases, if you choose us to fix. Optional.

Led by your team or ours, your choice · gate: your merge approval
07

Hand over

Readout, evidence pack and everything you need to carry on.

Led by our security lead · gate: your CISO's acceptance

Fast is only useful if it holds up.

Before speed, regulated buyers want to know their code is safe and the results will stand up to scrutiny. Here is how we make sure of both.

Read only, and provably so

We read your code. We never run it and never change it. At the end of the review, we can prove cryptographically that not a single byte was altered.

Runs where you need it

In your cloud, on your existing subscription. In a private environment we set up for you. Or fully offline, on your premises.

Nothing carries over to anyone else

Our pattern library grows from what we learn about types of vulnerability, never from your code. Nothing that identifies you or your systems is reused in another engagement.

A name on every finding

Every engagement has a named Nortal security lead accountable for the findings. Data handling is agreed in writing before we see a line of code. You can audit both the evidence pipeline and the data-handling schedule.

Mapped to the rules you answer to

Where it applies, we tag each finding to NIST SP 800-53, the UK Cyber Assessment Framework and NCSC Secure by Design. We produce the evidence. Your auditor makes the call. Every record is built to stand up as evidence when regulators ask you to prove your software is secure.

Related cyber work

Find the way in before someone else does.

Tell us which system you'd review first. You'll know what an attacker could reach, and what to fix first.

James Thomas

James Thomas

Global Head of Cyber

 

Plain answers to fair questions.

What CISOs and engineering leads ask us first, answered without the jargon.

It is our AI-powered secure code review: 13 specialist AI agents read your source code with read-only access, an independent AI verifier checks every finding, and deterministic code records the results as an evidence pack with one formal record per finding. A named Nortal security lead is accountable for the results. Every finding comes with a recommended fix, so your team, or anyone you choose, can close it, or our engineers can as a next step.

A static analysis scanner matches your code against known dangerous patterns. It is fast and thorough, but it doesn't understand what your system is for, so it misses flaws that only exist in context and can't connect separate weaknesses into one attack path. On our public benchmark, a free rule-based scanner found none of the documented vulnerabilities. We still use one, as a source of hints for the AI agents.

No. A penetration test attacks a running system. We read the code behind it, so we can see flaws a test from the outside never reaches. That includes where open-source and third-party components meet your code, and cloud configuration written as infrastructure as code. Testing AI systems themselves, such as chatbots and agents, is a companion service we run alongside this one.

You can, and it will find some vulnerabilities. What you get back is one prompt's view of your code: a long list with no owner. Agentic Code Review is a harness, not a single prompt. Its 13 specialist AI agents each hunt for one class of vulnerability over repeated passes, an independent AI verifier checks every finding, fixed-rule recording turns the results into evidence an auditor will accept, and a pattern library grows with every engagement. The difference is depth and how well each finding is verified.

Whichever is best for the job at the time, or the one you choose. The harness, prompts and pattern library are built separately from the model, so it runs on whatever model you want, wherever you want. The model is also the biggest cost driver, so you choose the balance between capability and cost.

Only where you decide. The review runs in your cloud, on your existing subscription. In a private environment we set up for you. Or fully offline, on your premises. Secret values are masked before they reach any record.

Measured against 20 public code repositories with documented vulnerabilities and scored against a known-answer key, our specialist agents found 70% of them in a single pass of the codebase and 95% after nine passes. The nearest frontier lab's free AI code reviewer reached 55%. The models may have seen that public code in training, so these are a conservative floor rather than a guarantee on your codebase.

It depends on the size of your codebase, the languages involved and the model you choose. A short scoping questionnaire gives us what we need to plan the work and quote it. If you ask our engineers to fix the findings too, that adds time, and the always-on option runs for as long as your code keeps changing.

The labs build excellent models, and we use them. What we add is the harness around the model: specialist agents for each language and vulnerability class, an independent AI verifier, chaining and evidence, sharpened by every codebase we have run it on. It works with whichever model you choose, so you are never tied to one lab's product, pricing or access decisions.

Everything: every finding, the evidence pack, remediation status, any fixes we wrote, and guidance on running the practice without us. We don't reuse your code or findings for other clients. Only anonymized bug-class patterns inform our method.