Introducing AI-Native Remediation: From Validated Finding to Reviewed Fix

How a validated finding becomes a reviewer-ready pull request with evidence, regression tests and a re-test, and why your team keeps the merge.

José Palanco José Palanco
Last Updated:
29 min read
Share
Introducing AI-Native Remediation: From Validated Finding to Reviewed Fix

Beyond ASPM

Proof-Driven AppSec for teams building with AI

Plexicus uses AI Swarm Pentest to explore authorized application paths, validate what is exploitable, and give teams evidence they can use to prioritize remediation.

Explore AI Swarm Pentest

Finding vulnerabilities has never been cheaper.

Fixing them has not kept up.

Scanners, pentests and AI agents now produce findings faster than engineering teams can read them. The backlog grows. The risk stays in production.

AI-native remediation is the practice of turning a validated security finding into a reviewer-ready code change, with the evidence, the reasoning and the tests attached, so that a human can merge it with confidence and a re-test can prove the fix worked.

It is not a bot that pushes patches to production.

It is the last step of a closed loop: prove the problem, understand it in the code, propose the change, let a person decide, then prove the problem is gone.

The need is measurable. In its 2026 Data Breach Investigations Report, Verizon found that exploitation of vulnerabilities had become the most common initial access vector, at 31% of the breaches in its dataset with a known initial access vector. The same report found that only 26% of the CISA Known Exploited Vulnerabilities (KEV) found in organizations’ environments were fully remediated in 2025, down from 38% the year before, and the median time to full resolution rose to 43 days.

Attackers are using the gap between “found” and “fixed”. AI-native remediation is about closing it without giving up control.

What Is AI-Native Remediation?

AI-native remediation is a remediation workflow designed around AI from the start: the system reads a validated finding, gathers the code context around it, drafts a minimal fix with tests and an explanation, opens it as a pull request for human review, and re-tests the original proof after the change.

Three words in that definition do most of the work.

Validated. The input is a finding that has been shown to be real, not a raw alert. If the problem cannot be reproduced, there is nothing to fix yet.

Reviewer-ready. The output is a change a developer can evaluate in minutes: a small diff, the reason it addresses the weakness, the tests that cover it, and the source locations involved.

Re-tested. The fix is not done when it merges. It is done when the original proof no longer works.

Remove any one of those and you get something weaker.

Without validation, you automate fixes for problems that may not exist.

Without review, you hand write access to a model.

Without a re-test, you have a change that looks right and might not be.

Why Remediation Is the Bottleneck in 2026

Detection scaled first. Remediation did not.

The numbers from independent sources point the same way.

The patching data.

The 2026 DBIR measured remediation of KEV-listed vulnerabilities that scanners found in organizations’ environments, using aggregated data from more than 13,000 organizations. Three findings stand out:

  1. Only 26% of those KEV vulnerabilities were fully remediated in 2025, compared with 38% the previous year.
  2. The median time to full resolution went from 32 days to 43 days.
  3. The median organization had 16 KEV vulnerabilities to patch, up from 11 the year before, which the report calls almost 50% more.

Bar charts comparing the share of CISA KEV vulnerabilities found in organizations' environments that were fully remediated and the median days to full resolution, prior year versus the 2026 Verizon DBIR

Chart made by Plexicus from figures published in the Verizon 2026 Data Breach Investigations Report; the prior-year values are the ones that report states for comparison.

These figures describe patching of known vulnerabilities across organizations’ environments, not fixes in first-party application code. They still show the shape of the problem: the queue grows faster than teams close it.

The deadlines.

For U.S. federal agencies, the clock is not a matter of preference. CISA’s Binding Operational Directive (BOD) 26-04, issued on 10 June 2026, revoked BOD 22-01 and replaced that directive’s default KEV deadlines with risk-based remediation timelines for federal civilian executive branch agencies.

Four factors set the timeline for each asset:

  • Whether it is publicly exposed.
  • Whether the vulnerability is in the KEV catalog.
  • Whether an adversary can automate every step needed to exploit it.
  • Whether a successful exploit gives partial or total control of the asset.

The timelines change as those facts change: a vulnerability’s timeline shortens when CISA adds it to the KEV catalog. Agencies must already remediate KEV vulnerabilities by the due dates in the KEV catalog, and must meet the full timelines for every vulnerability with a CVE ID within 180 days of issuance.

In Europe, the Cyber Resilience Act entered into force on 10 December 2024. According to the European Commission, its reporting obligations apply from 11 September 2026 and its main obligations from 11 December 2027. Manufacturers of products with digital elements now have to report actively exploited vulnerabilities.

Regulation does not write patches. It does shorten the time a team can spend deciding whether to.

The code being written.

The volume of new code is also changing. Veracode’s 2025 GenAI Code Security Report tested more than 100 large language models on coding tasks and reported that 45% of the code samples failed security tests and introduced OWASP Top 10 weaknesses. These are vendor-reported results from Veracode’s own test set, not an independent replication.

Even read with that caveat, the direction is clear. AI coding tools increase the amount of code that reaches review. Some of that code carries the same classic flaws security teams have fixed for twenty years.

The disclosure volume.

MITRE’s 2025 CWE Top 25 methodology analyzed 39,080 CVE records published between June 1, 2024 and June 1, 2025. That is one year of published CVE records, before counting what your own scanners and tests find in your own code.

More findings, tighter deadlines, more code. The constraint is no longer seeing the problem. It is closing it.

What “AI-Native” Means, and What It Does Not

“AI-native” is easy to misuse, so it helps to be precise.

An AI-native remediation workflow is one where the AI is part of the pipeline’s design: it receives structured evidence, works against the real repository, produces a structured output, and is checked by tests and by a person.

It is different from bolting a chat window onto a scanner.

It is also different from autonomy without limits.

The AI drafts. Tests check. People decide. A re-test confirms.

In that sense, “AI-native” describes where AI sits in the loop, not how much authority it holds.

The more of the work the AI does, the more evidence and review the workflow needs around it.

AI-Native Remediation vs. Automated Patch Management

Automated patch management and dependency update bots solve a narrower problem very well.

GitHub’s documentation for Dependabot security updates describes the pattern: when a dependency has a published advisory, Dependabot checks whether it can upgrade to a fixed version without breaking the dependency graph, then raises a pull request that updates the dependency to the minimum version that includes the patch.

That is a valuable workflow. Keep it.

But it answers one question: is there a newer version of this package without the known vulnerability?

The version-bump pull request itself does not answer:

  • Does your code actually call the vulnerable function?
  • Is the flaw in your own code rather than in a library?
  • Does the fix require changing how your application calls the library?
  • Is the real problem an authorization check that was never written?

AI-native remediation starts from a different input. It begins with a validated finding in your application, including first-party code, and it can propose changes to that code, not only to a manifest.

The two approaches work well together. A version bump is often the right fix. Sometimes it is not enough.

AI-Native Remediation vs. AI Code Suggestions

Inline AI suggestions in an editor or a pull request help a developer who is already looking at the problem.

They are useful. They are also a different thing.

An inline suggestion usually starts from a scanner alert or a developer prompt. It proposes an edit. The developer decides whether the alert was real and whether the edit is correct.

AI-native remediation moves two of those decisions earlier and makes them explicit:

  1. Is the finding real? The workflow only accepts validated findings with evidence.
  2. Does the fix work? The workflow attaches tests and re-runs the original proof.

The developer still reviews the change. They review it with more context and less guessing.

AI-Native Remediation vs. Manual Remediation

Manual remediation is the baseline, and it remains the right tool for the hardest problems.

A senior engineer understands design intent, team conventions and business rules that no finding report contains. For a flaw rooted in architecture, a person should lead.

The weakness of manual remediation is not quality. It is throughput and consistency.

Each finding needs someone to reproduce it, locate it, understand it, design a fix, write tests and open a pull request. That work competes with the product roadmap, and the roadmap usually wins.

AI-native remediation takes over the repetitive part of that sequence and keeps the decision with the engineer.

Comparison table of manual remediation, dependency update bots, AI code suggestions and AI-native remediation by input, output, verification and who merges

Original Plexicus comparison of the four approaches as concepts; it does not describe any named product.

How AI-Native Remediation Works

A complete workflow has seven stages. Each one hands the next a specific artifact. The diagram below groups them into five steps.

Validated finding + evidence
        ↓
Code context and root cause
        ↓
Fix strategy
        ↓
Drafted change + tests + rationale
        ↓
Automated checks (CI)
        ↓
Human review and merge decision
        ↓
Re-test against the original proof

Five-step flow from validated finding to code context, drafted change, human review and re-test, with a loop back when the proof still reproduces

Original Plexicus diagram of the remediation loop; it is a conceptual flow, not a product screenshot.

1. Start from a validated finding

The input is a finding with evidence: the request that triggered the flaw, the response that proved it, the data that was reached, the role that could reach it.

A finding without evidence is a hypothesis. Remediation on a hypothesis wastes review time and erodes trust in every later pull request.

2. Gather code context and the root cause

The system traces the finding back to code: the endpoint, the handler, the function, the parameter and the data flow between them.

It also identifies the weakness class, usually as a CWE entry such as CWE-89 for SQL injection. The class matters because the fix pattern depends on it.

Here is the code context for a finding in the Plexicus platform.

Plexicus finding detail for a high-severity Missing Authorization finding, with the Java code and the flagged line, the AI verdict, and an Actions menu offering Create AI Remediation

Screenshot: the finding detail in the Plexicus platform for a Missing Authorization finding (CWE-862) in a demo Java application. It shows the Code & taint trace section, the AI verdict, and Create AI Remediation in the Actions menu. Demo data, captured October 2026; the issue owner’s email address is pixelated.

3. Choose a fix strategy

Most weakness classes have known-good fix patterns.

Parameterized queries for injection. An ownership check for object-level authorization. A version upgrade for a vulnerable dependency.

The strategy also decides scope. The best fix is usually the smallest change that removes the weakness at its source.

4. Draft the change, the tests and the explanation

The output is a diff, a short rationale that ties each changed line to the finding, and tests that would have failed before the fix.

A regression test is what keeps the same flaw from coming back in six months.

Here is an AI-generated remediation being reviewed in the Plexicus platform.

Video: a clip from the Plexicus platform walkthrough. In the AI Remediation Details dialog for a command injection finding, the Details tab explains the vulnerability and the fix, the Code Changes tab shows the diff of app.py, and the clip ends with the pull request being created. Recorded in May 2026.

5. Run the automated checks

The change goes through the same CI pipeline as any other pull request: build, unit tests, linters and existing security checks.

An AI-drafted fix gets no shortcut. If anything, it gets the full pipeline every time.

6. Hand the decision to a human

The change arrives as a pull request in the repository your team already uses. A reviewer reads the diff, the evidence and the rationale, then merges, edits or rejects it.

The reviewer owns the merge.

Here is what a finding looks like once a fix has been submitted, in the Plexicus platform.

Plexicus finding detail for a critical SQL Injection finding with the status Fix Submitted, and the buttons Create Ticket, See Pull Request and View AI Remediation above the Code & taint trace section

Screenshot: a critical SQL injection finding (CWE-89) in a demo Java application, shown in the Plexicus platform with the status Fix Submitted. The toolbar offers Create Ticket, See Pull Request and View AI Remediation. Demo data.

And here is a pull request for a command injection finding, as it reaches the repository.

Video: a clip from the Plexicus platform walkthrough. The live status log ends with the pull request created; on GitHub it is opened by a Plexicus bot account with one commit and the explanation of the fix in its description, and a person then merges it. This recording shows no CI checks and no reviews on the pull request. Recorded in May 2026.

7. Re-test against the original proof

After the change, the original proof is replayed. If the exploit still works, the finding stays open. If it fails, the finding can be closed with evidence on both sides: it reproduced before, and it does not reproduce after.

That last step is what turns a code change into a closed finding.

Why the Input Has to Be a Validated Finding

It is tempting to point a fixing agent at the full output of every scanner.

That multiplies noise.

Every false positive becomes a pull request. Every pull request takes a reviewer’s time. After a few rejected changes, reviewers start approving or ignoring them without reading, which is worse than having no automation at all.

Starting from validated findings changes the economics of review. Every change a reviewer sees is tied to a problem that was shown to be real.

That is the core of Proof-Driven AppSec: no PoC, no finding. The same rule applies one step later. No validated finding, no automated fix.

For more on how validation works, see our explainer on AI Swarm Pentest, which covers independent reproduction before a finding is presented as verified.

Why the Output Has to Be a Pull Request, Not a Push

A pull request is the control point your engineering organization already trusts.

It carries a diff and runs CI. It records who approved what and when, and it can be reverted.

The OpenSSF Scorecard project treats this as a basic practice. Its Code-Review check determines whether a project requires human code review before pull requests are merged, and rates the risk of skipping it as high.

That standard should apply with more force, not less, when the author is an AI.

An AI-native remediation workflow therefore never needs direct write access to production. It needs the ability to open a branch and a pull request. Everything after that is your normal process.

What the Research Says About AI-Generated Security Fixes

The research on AI-written security patches is encouraging and sobering at the same time. Four sources are worth knowing.

LLMs can repair simple cases, real code is harder.

In “Examining Zero-Shot Vulnerability Repair with Large Language Models”, published at the 2023 IEEE Symposium on Security and Privacy, Pearce and colleagues tested five commercially available models, one open-source model and a locally trained model on synthetic, hand-crafted and real-world vulnerability scenarios.

The models collectively repaired all of the synthetic and hand-crafted scenarios. On historical real-world examples, the authors reported challenges in generating functionally correct code.

Lesson: a fix that compiles is not the same as a fix that works.

At scale, a modest success rate still matters.

Google’s technical report on AI-powered patching describes a pipeline that prompts Gemini to generate fixes for sanitizer-found bugs in C/C++, Java and Go, then surfaces them for human review.

Google reports that the approach successfully fixed 15% of the sanitizer bugs discovered during unit tests, resulting in hundreds of bugs patched. This is a company-reported result from Google’s own pipeline, not an independent replication.

Lesson: even a partial automation rate removes real work, as long as humans review what ships.

Patch quality has to be tested, not judged by similarity.

In “Fixing Security Vulnerabilities with AI in OSS-Fuzz”, researchers adapted an LLM agent to fix vulnerabilities found by OSS-Fuzz, which the paper says has identified more than 10,000 vulnerabilities across 1,000 or more projects.

One of their findings is directly relevant to remediation design: patches that scored highly on code-similarity metrics still failed when the exploit input was run against them. The authors conclude that security patch correctness has to consider dynamic attributes such as test execution.

Lesson: the exploit is part of the test. A fix is not correct until the proof stops working, however much the diff looks like a known fix.

Competition systems can find and patch at speed.

DARPA’s AI Cyber Challenge final results, announced on 8 August 2025, report that competing systems discovered 54 unique synthetic vulnerabilities across the final competition’s 63 challenges and patched 43 of them. Teams also found 18 real, non-synthetic vulnerabilities and provided 11 patches for real vulnerabilities. DARPA reports an average of 45 minutes to submit a patch.

These are competition results on real-world open-source software chosen for the challenge, under the competition’s scoring rules. They show what is possible, not what any given team will see in its own code.

What the evidence does not establish.

None of these sources shows that AI can fix every vulnerability unattended.

They show that AI can draft a useful share of fixes and that correctness must be checked by running the proof. Only Google’s production pipeline puts a person in the loop; the other three measure autonomous systems under test conditions.

That is why a production workflow adds human review on top. It is exactly the design of an AI-native remediation workflow.

The exploit is the best regression test.

Most security fixes are verified by reading them.

A reviewer looks at the diff, recognizes a parameterized query, and approves.

That works for familiar patterns. It fails for subtle ones: an authorization check placed after the data is loaded, a sanitizer that misses one encoding, a dependency upgrade that leaves a vulnerable transitive copy in place.

When the finding came with a working proof, the strongest check is simple:

Proof reproduced before the fix:  YES
Proof reproduced after the fix:   NO
Regression tests:                 PASS
Reviewer approval:                YES

That four-line record is stronger evidence than reasoning about the diff alone.

It is not proof of a complete fix. A change that blocks only the original payload also passes the replay, so the regression tests should include variants of the input, such as other encodings.

It is also the record an auditor, a customer or a regulator will eventually ask for.

What Kinds of Flaws Can AI-Native Remediation Fix?

Not every finding is a good candidate. The fit depends on how local the fix is and how well the fix pattern is understood.

Classic code flaws.

Injection, cross-site scripting, server-side request forgery, insecure deserialization and weak cryptography usually have well-known fix patterns. The OWASP Top 10

lists Injection as A05 and Cryptographic Failures as A04.

Strengths: fixes are often local to one function, the pattern is standard, and a regression test is easy to write.

Limitations: the same flaw can appear in more than one place, and a fix in one call site does not cover the others. The workflow should search for the same pattern elsewhere, which is what NIST’s SSDF calls reviewing the software for similar vulnerabilities to eradicate a class.

Access control and business-logic flaws.

Broken Access Control is A01 in the OWASP Top 10

. It covers flaws such as missing ownership checks and privilege escalation. Business-logic flaws, such as a missing rate limit, sit next to it.

Strengths: a validated finding shows exactly which user reached which object, which makes the missing check concrete.

Limitations: the correct rule depends on business intent. Should a team admin see every project in the organization, or only their team’s?

The AI can draft the check. A person has to confirm the rule.

Dependency and supply-chain exposure.

Vulnerable versions, typosquatted names and packages that should never have been installed.

Strengths: version upgrades and package replacements are mechanical, and lockfile changes are easy to review.

Limitations: major-version upgrades can break APIs. A fix may need code changes alongside the version bump, and tests matter more here than anywhere.

Flaws introduced while coding with AI.

Hallucinated package names, hardcoded secrets, prompt-injection sinks and authorization gaps in generated code.

Strengths: these flaws often follow recognizable patterns and sit in recently changed code, which keeps the fix scope small.

Limitations: generated code may have no tests at all, so the remediation has to add them, not only change the code.

Architectural flaws.

A system that trusts an internal network boundary, or a design that puts secrets on the client.

Strengths: the evidence still helps a team understand and prioritize the problem.

Limitations: these rarely have a safe small diff. The right output is a clear explanation and a plan for the team, not an automated pull request.

When Is an Auto-Fix Pull Request Safe to Merge?

“Safe to merge” is a reviewer’s judgment. These questions make that judgment faster and more consistent.

  1. Was the finding validated? Is there evidence that the weakness was real and reachable?
  2. Is the diff minimal? Does every changed line relate to the finding?
  3. Is the rationale specific? Does it name the weakness class, the source location and why the change removes it?
  4. Are there regression tests? Would they have failed before the change?
  5. Does CI pass? All of it, with no skipped jobs.
  6. Does the proof fail after the fix? Has the original exploit or reproduction been replayed?
  7. Does the fix change behavior users rely on? If yes, has the product owner seen it?
  8. Is the same pattern present elsewhere? If yes, is there a follow-up?

If any answer is “no” or “unknown”, the pull request is not ready, however clean the diff looks.

Best Practices for AI-Native Remediation

1. Feed it evidence, not alerts

Only validated findings should enter the remediation queue. Everything else stays in triage.

2. Keep the evidence attached to the change

The pull request should link to the finding, its proof and its context. A reviewer should never need to open another tool to understand why the change exists.

3. Prefer the smallest correct fix

Small diffs are easier to review, easier to test and easier to revert. Refactors belong in separate pull requests.

4. Require tests with every fix

A security fix without a test is a fix that can silently disappear in the next refactor.

5. Use your existing review rules

Branch protection, required reviewers and CI gates should apply to AI-drafted changes exactly as they apply to human ones.

6. Re-test after merge, not only before

Replay the proof against the deployed change. A fix that works on a branch and fails after deployment is not a fix.

7. Track root causes over time

Record the weakness class of every fix. If the same class keeps returning, the problem is upstream, in a library, a template or a coding habit.

8. Start with well-understood classes

Begin with weakness classes that have standard fix patterns. Expand scope once reviewers trust the output.

Common Mistakes

Automating fixes for unvalidated findings. Reviewers drown in changes for problems that never existed.

Letting the AI push directly to a protected branch. It removes the one control that makes the whole workflow trustworthy.

Judging a fix by how it reads. Similarity to a known fix is not correctness, as the OSS-Fuzz study showed.

Skipping regression tests because CI is green. Green CI only covers what the tests check.

Treating every finding as fixable by code. Some problems need a design decision, not a diff.

Measuring success by pull requests opened. The metric that matters is findings closed with a passing re-test.

Standards and Frameworks That Apply

AI-native remediation is a new way to do work that existing standards already describe.

NIST Secure Software Development Framework.

NIST SP 800-218, the Secure Software Development Framework (SSDF) published in February 2022, has a practice group called Respond to Vulnerabilities (RV). Its tasks map closely onto the workflow above:

SSDF taskWhat it asksWhere it appears in the workflow
RV.2.1Analyze each vulnerability to gather enough information about risk to plan its remediationValidated finding and code context
RV.2.2Plan and implement risk responses for vulnerabilitiesDrafted change and review
RV.3.1Analyze identified vulnerabilities to determine their root causesRoot cause and weakness class
RV.3.2Analyze the root causes over time to identify patternsRoot cause tracking over time
RV.3.3Review the software for similar vulnerabilities to eradicate a class of vulnerabilitiesSearch for the same pattern elsewhere
RV.3.4Review the SDLC process, and update it if appropriate to prevent (or reduce the likelihood of) the root cause recurringFixing the library, template or habit upstream

The SSDF also asks, in PW.7.2, that code review and analysis results and recommended remediations are recorded in the development team’s workflow or issue tracker. A pull request with evidence attached does that by design.

CISA KEV and BOD 26-04.

For federal agencies, BOD 26-04 sets the remediation timelines described earlier, and KEV status is one of its four factors. For everyone else, the KEV catalog is a practical priority list: if a vulnerability is known to be exploited, it goes to the front of the remediation queue.

OWASP Top 10

.

The OWASP Top 10

gives a shared vocabulary for the classes of flaws that remediation workflows handle most: Broken Access Control, Security Misconfiguration, Software Supply Chain Failures, Cryptographic Failures, Injection and more.

EU Cyber Resilience Act.

The CRA puts vulnerability handling into law for products with digital elements sold in the EU. A remediation record that shows the finding, the fix, the review and the re-test is the kind of evidence that handling process will need.

A Practical Example

Imagine an invoicing API built with help from an AI coding assistant.

An authorized pentest finds that a user can download another customer’s invoice by changing the ID in the URL:

GET /api/invoices/8812/pdf     (account A, owns invoice 8812)    200 OK
GET /api/invoices/8813/pdf     (account A, invoice of account B) 200 OK

The second request should have been refused. The finding is reproduced independently and marked as validated, with both requests and responses kept as evidence.

Code context.

Tracing the route leads to one handler:

@app.get("/api/invoices/<int:invoice_id>/pdf")
@login_required
def invoice_pdf(invoice_id):
    invoice = Invoice.query.get_or_404(invoice_id)
    return render_pdf(invoice)

The weakness class is missing authorization on a user-controlled key, CWE-639. The user is authenticated. Ownership is never checked.

Drafted change.

The proposed diff adds the missing check at the point where the object is loaded:

 def invoice_pdf(invoice_id):
-    invoice = Invoice.query.get_or_404(invoice_id)
+    invoice = Invoice.query.filter_by(
+        id=invoice_id, account_id=current_user.account_id
+    ).first_or_404()
     return render_pdf(invoice)

Returning 404 instead of 403 also avoids confirming that the other invoice exists.

Tests.

Two tests come with the change. Here client_a is a project fixture: a test client already logged in as a user of account A.

def test_owner_can_download_invoice(client_a, invoice_a):
    assert client_a.get(f"/api/invoices/{invoice_a.id}/pdf").status_code == 200

def test_other_account_cannot_download_invoice(client_a, invoice_b):
    assert client_a.get(f"/api/invoices/{invoice_b.id}/pdf").status_code == 404

The second test fails on the old code and passes on the new code.

Review and re-test.

The pull request explains the finding, links the evidence, shows the diff and the tests, and flags one question for the reviewer: are there other invoice routes, such as email or export, that load invoices the same way?

The reviewer checks, finds one more route, and asks for the same fix there.

After merge and deployment, the original requests are replayed:

GET /api/invoices/8812/pdf     (account A, owns invoice 8812)    200 OK
GET /api/invoices/8813/pdf     (account A, invoice of account B) 404 Not Found

The finding closes with proof on both sides.

What AI-Native Remediation Is Not

It is not an agent with write access to production.

It is not a replacement for code review.

It is not a guarantee that every finding can be fixed automatically.

It is not a way to skip tests because the AI “understood” the code.

And it is not a reason to stop fixing root causes. If the same flaw appears every week, the answer is a safer library or a better template, not a faster fixer.

Where Plexicus Fits

Plexicus is built around a closed loop: validate, understand, remediate, then verify the fix before merge.

Validate. AI Swarm Pentest explores an authorized application, API or source code within an agreed scope. Every finding includes reproducible evidence, and if a second pass cannot reproduce the result, the finding is marked unverified or discarded.

Understand. Deep Code Analysis traces the affected code path, so engineers see the endpoints, parameters and business logic a finding touches, along with the data it can reach and the role that can trigger it.

Remediate. Plexicus Remediation takes a verified finding and prepares the remediation context and a suggested change. The affected flow, reach, weakness class and rationale are bundled into the proposed change. The reviewer-ready diff explains the original finding inline, and regression tests and notes are included where relevant.

Hand over. The change lands in your existing repository with reviewer assignment and a re-test hook wired to CI, and your team verifies it before merge. Plexicus lists GitHub, GitLab and Bitbucket for repositories. Your team merges or rejects with evidence.

Keep control. Plexicus never pushes to production, and your team decides whether to merge. The AI Swarm Pentest page adds that proposals arrive as pull requests or separate patch files.

Plexicus describes four kinds of fixes it prepares: flaws introduced while building with AI coding tools, classic findings such as SQL injection and cross-site scripting, business-logic flaws such as broken object-level authorization, and supply-chain exposure such as typosquatted dependencies, with version pinning and lockfile updates.

That is Proof-Driven AppSec applied to the last mile: a closed loop with PR, where every change carries the evidence that produced it.

If you are earlier in the journey, our complete guide to application security covers where remediation sits in a modern AppSec program, and our explainer on deep code analysis covers why code context matters before a fix is drafted. For a worked fix pattern, see how to automate SQL injection remediation.

Frequently Asked Questions

What is the difference between AI-native remediation and auto-remediation?

Auto-remediation often means applying a predefined action automatically, such as a patch or a configuration change. AI-native remediation drafts a code change for a specific validated finding and hands it to a person for review before anything merges.

Does AI-native remediation push changes to production?

It should not. The output is a pull request or a patch file, reviewed and merged through your normal process. Plexicus states that it never pushes to production.

Can AI fix vulnerabilities correctly?

Sometimes, and the research shows how to tell. Google reports that its pipeline fixed 15% of the sanitizer bugs discovered during unit tests, with human review. The OSS-Fuzz study shows that patches must be checked by running the exploit, not by how similar they look to a known fix.

Why start from validated findings instead of scanner output?

Because every unvalidated finding that becomes a pull request costs review time and may fix nothing. Validation makes each change worth a reviewer’s attention.

What tests should come with a security fix?

At least one test that fails on the old code and passes on the new code, plus a test that confirms legitimate use still works. For access control flaws, test both the owner and a different account.

Does AI-native remediation replace developers or security engineers?

No. It takes over the repetitive parts: reproducing, locating, drafting and testing. People still decide what the correct behavior is and whether the change merges.

Which vulnerabilities are good candidates?

Flaws with local, well-understood fix patterns, such as injection, missing ownership checks and vulnerable dependency versions. Architectural flaws usually need a plan, not an automated diff.

How does this relate to the NIST SSDF?

The SSDF’s Respond to Vulnerabilities practices ask teams to analyze each vulnerability, implement a response, find root causes and look for the same flaw elsewhere. An AI-native remediation workflow is one way to carry out those tasks at higher volume.

How do you measure whether it works?

Count findings closed with a passing re-test, and the time from validation to merge. Pull requests opened is not a useful measure on its own.

Can it fix code written by AI coding assistants?

Yes, and that code often needs it. Generated code can carry classic flaws and may arrive without tests, so the fix should add tests as well as change the code.

Close the Loop With Evidence

Every fix should prove the finding was real, show why the change works, and show that the attack stopped.

Explore Plexicus Remediation →

Want a first look at your own code? Run the free SAST tool, a static scan of your GitHub source code.

Written by
José Palanco
José Palanco
José Ramón Palanco is the CEO/CTO of Plexicus, a pioneering company in ASPM (Application Security Posture Management) launched in 2024, offering AI-powered remediation capabilities. Previously, he founded Dinoflux in 2014, a Threat Intelligence startup that was acquired by Telefonica, and has been working with 11paths since 2018. His experience includes roles at Ericsson`s R&D department and Optenet (Allot). He holds a Telecommunications Engineering degree from the University of Alcala de Henares and a Master`s in IT Governance from the University of Deusto. As a recognized cybersecurity expert, he has been a speaker at various prestigious conferences including OWASP, ROOTEDCON, ROOTCON, MALCON, and FAQin. His contributions to the cybersecurity field include multiple CVE publications and the development of various open source tools such as nmap-scada, ProtocolDetector, escan, pma, EKanalyzer, SCADA IDS, and more.
Read More from José
More to read

Related posts

Ready to validate what matters?

Ready to validate what matters?

Plexicus is Proof-Driven AppSec: validated findings, contextual understanding, and reviewed remediation — anchored in evidence, scoped with you.

Qualification

Check whether AI Swarm Pentest fits your environment.

Share the minimum context. We will review the scope and tell you the next commercial step.

Before submitting — verify you fit

0 / 280

No commitment. If you don't fit, we'll tell you.

SAMPLE HANDOVER · ILLUSTRATIVE

Sample evidence handover

A trimmed view of what your team receives at the end of an AI Swarm Pentest engagement. Real engagements include full technical evidence, executive narrative, and a remediation plan.

VALIDATED FINDING Evidence attached

Server-Side Request Forgery in webhooks/receiver

demo-project/sample-app · src/webhooks/receiver.py:42

SeverityHigh CVSS 3.18.6 Priority79 Confirmedvia replay

Untrusted caller-supplied URLs reach an internal egress without an allowlist. Replayed in a sandbox against a fresh authorized target — the same control was validated to fail twice.

REVIEWER-READY REMEDIATION Merge-ready PR

Validate the target URL against an allowlist of permitted hostnames. Reject private/internal IP ranges. Enforce HTTPS only.

plexicus/remediation/webhooks-ssrf 3 changed · 0 new files
42resp = requests.get(target_url)
42+if not is_allowed_host(target_url):
43+  raise WebhookRejected(target_url)
44+resp = requests.get(target_url, timeout=5)
Every engagement hands over:
  • Executive briefing
  • Validated findings list
  • Merge-ready PRs
  • Compliance mapping (NIS2 · DORA · CRA)
Private Round For investors