Can LLMs Triage SAST Findings? What the Evidence Says
We review the published evidence on LLM triage of SAST findings, show what it costs in missed bugs, and give you a harness to measure it on your own code.
On 26 January 2026, a research team working with Tencent published something AppSec teams rarely get: a measured answer from production. They took 433 alarms from Tencent's in-house static analyser on real C/C++ code, every one labelled through the company's normal two-round review. Each alarm had taken engineers 10 to 20 minutes to inspect by hand. The best LLM-based method removed 94–98% of the false positives. The same paper also notes that its recall stayed below the 90% the business expects. Put simply, the tools that cleared the noise also dropped real bugs.
That trade is the whole story of LLM triage for static analysis, and most vendor pages leave out the second half. This article is for the people who have to decide whether to let a model close findings: AppSec leads, CISOs, platform engineering and the AI teams being asked to "just add a judge". We review what the published studies actually measured and what they did not. We show the cost in missed bugs that headline numbers hide. And we give you a reproducible harness to measure it on your own code before you switch anything on.
TL;DR / Key takeaways
- The noise is real, and LLMs can cut it. In Tencent's industrial study, hybrid designs that give the model precise code context removed 84–98% of false positives. Simple "is this a false positive?" prompting removed only 26–52% in the same industrial setting.
- Every published gain costs recall. Tencent's best methods kept 75–88% of real bugs. QASecClaw lost 40 true positives on the OWASP Benchmark. If a model auto-closes findings, those misses become silent.
- Benchmarks flatter the models. On the OWASP Benchmark around 70% of alerts are real; in Tencent's production data it was 24%, and under 10% before pre-filtering. Your base rate decides what the numbers mean.
- Measure before you trust. You need blind human labels, recall with a confidence interval and at least 100 confirmed real bugs. With 45, a measured 85% recall could really be anything from 72% to 93%.
- Let the LLM rank, not delete. Start with advisory verdicts and rationales, add suppression only for low-risk weakness classes with measured recall, and audit a sample of everything it closes.
Download: Editable draw.io file · Open in diagrams.net · Chart data (CSV)
Why this matters now
Static analysis has always had a precision problem, and 2026 made it more expensive. The Tencent study puts the false-positive rate of its static warnings above 90% once alarms that were discarded before labelling are counted. Even after that pre-filtering, 328 of the 433 labelled alarms were false. That is in line with what we see in enterprise pipelines. Developers learn quickly that most SAST comments are wrong, and then they stop reading all of them, including the right ones.
At the same time, in our experience AI coding assistants are pushing more code through the scanners. The scanners themselves now ship LLM triage features. Semgrep's documentation describes AI "autotriage" that suggests which findings can be ignored, and a noise-filtering feature in beta that suppresses likely false positives in pull-request comments. It states the feature is "over 95% accurate in categorizing Semgrep Code findings as false positives", without saying how that was measured. Datadog described a Bits AI false-positive filter for its static analysis in October 2025. It evaluated the filter on the OWASP Benchmark and published no figures. GitHub Security Lab described in January 2026 how it uses LLM "taskflows" to triage CodeQL alerts, and credits the approach with about 30 real vulnerabilities found since the previous August.
So the question is no longer whether to use an LLM on SAST output. Your vendor will switch it on for you. The question is what you let it decide, and how you would know if it was wrong. With Cyber Resilience Act reporting in force since 11 September 2026, a suppressed true positive is exactly the kind of decision an auditor will ask about.
What the published evidence says
We read the studies with primary data on LLM triage of static-analysis findings, from late 2023 to November 2026. Note that triage is not detection: the model judges one alert and the code around it. And papers define the positive class differently, so we report everything as "share of false positives removed" and "share of real bugs kept".
The industrial study (Tencent, 2026). Du et al. evaluated six techniques with four models (GPT-4o, Claude-Opus-4, Qwen-3-Coder and DeepSeek-R1). The alarms were null-pointer dereference, out-of-bounds and divide-by-zero findings from Tencent's BkCheck analyser. Ground truth came from the company's own review process: developers labelled first, dedicated reviewers checked, and senior reviewers resolved disagreements. Basic prompting removed 26–52% of false positives and kept 62–84% of real bugs. The hybrid techniques LLM4SA and LLM4PFA, which feed the model precise code context and path constraints, removed 84–98% of false positives, but recall stayed between 65% and 88%. Cost was not the obstacle: the paper reports 2.1 to 109.5 seconds and $0.0011 to $0.12 per alarm. Its authors also report that model explanations cut human validation time from about ten minutes to about three.
ZeroFalse (2025). Iranmanesh et al. fed CodeQL alerts, flow traces and CWE-specific guidance to ten models. The best F1 scores were 0.912 on the OWASP Java Benchmark (1,974 CodeQL alerts) and 0.955 on the smaller OpenVuln set (58 alerts). The paper also shows how much results move between models and datasets. In its results, Gemini 2.5 Pro scored F1 0.910 on OWASP and 0.372 on OpenVuln, because its recall collapsed on the real-world set. The authors report that CWE-specific prompts beat generic ones, although a few model and dataset combinations got worse.
QASecClaw (2026). Ameen et al. put a multi-agent LLM filter, built on Qwen 3.5 Plus, after Semgrep Community Edition on OWASP Benchmark v1.2 (2,740 Java test cases). False positives fell from 560 to 64, an 88.6% cut. Precision rose from 0.695 to 0.951 and recall fell from 0.900 to 0.871. That is 40 real vulnerabilities that Semgrep found and the filter threw away. On one class, trust boundary violation (CWE-501), the filter made F1 worse: 0.593 against Semgrep's 0.768.
LLM4PFA (2025) is the path-feasibility method that later did best in the Tencent study. Its own paper reports filtering 72–96% of false positives while missing 3 of 45 real bugs.
SAST-Genius (2025). Agrawal and Ahi paired Semgrep with a fine-tuned Llama 3 8B and report false positives falling from 225 to 20, and precision rising from 35.7% to 89.5%, across 25 open-source projects. These are the authors' own figures on a dataset they built.
The sceptical evidence. Ullah et al. (IEEE S&P 2024) tested eight LLMs on 228 code scenarios and found non-deterministic answers and unfaithful reasoning; small changes such as renaming functions or variables, or adding library functions, produced wrong answers in 17% of cases for GPT-4 and 26% for PaLM 2. Ding et al. (ICSE 2025) showed a model scoring 68.26% F1 on the older BigVul benchmark dropping to 3.09% on their cleaner PrimeVul set, with GPT-3.5 and GPT-4 no better. Both test detection, not triage, but they explain why the triage methods that work all add structure: traces, constraints and CWE guidance.
Our reading of the field fits in one sentence. An LLM given the right evidence is a very good filter, but no published configuration is good enough to close findings unsupervised without measuring recall on your own code.
The harness, step by step
This is the part you can reuse. The hero diagram shows a triage harness with two loops. The production loop sends findings through an evidence pack and an LLM judge to a routing policy. The evaluation loop runs offline with blind human labels and decides what the routing policy is allowed to do. The numbers below match the callouts in the diagram.
① SAST scan: collect and normalise findings
Start from SARIF, which Semgrep, CodeQL and most commercial scanners emit. De-duplicate by the scanner's fingerprint, because the same finding shows up on every branch and every re-run. You want one record per distinct finding, not per scan. Record the rule ID, CWE, file, line and commit. Without stable identifiers you cannot join LLM verdicts to human labels later. And do not pre-filter on severity here: a harness that only sees "high" findings tells you nothing about the medium ones you actually want to suppress.
② Evidence pack: give the judge what a human would look at
The single clearest lesson from the literature is that context beats cleverness. The hybrid methods that worked at Tencent fed the model the right slice of code and the path constraints. The prompting tricks that did not work (chain-of-thought, few-shot, bug-type hints) mostly did not. ZeroFalse's gains came from flow traces and CWE-specific guidance. Build the evidence pack the way a senior reviewer would:
- the code around the sink, and the function that contains the source;
- the source-to-sink trace from the scanner, if it emits one (CodeQL does for path queries);
- the CWE description and what usually makes it exploitable, written per weakness class;
- known sanitisers, framework defaults and project conventions (for example "all SQL goes through this repository layer").
Keep the builder deterministic and versioned, or you cannot compare runs.
③ LLM judge: a structured, pinned verdict
Ask for structure, not prose. A verdict schema we use:
{
"finding_id": "sarif-fingerprint",
"verdict": "real | false_positive | unsure",
"confidence": "high | medium | low",
"rationale": "two to five sentences",
"evidence_lines": ["src/api/orders.py:118", "src/db/repo.py:42"],
"exploit_precondition": "what an attacker would need, or null"
}Three rules make the judge testable. Pin the model version, prompt hash and temperature, and log them with every verdict. Make "unsure" a first-class answer and route it like "real". And require the rationale to cite line numbers that exist in the evidence pack. A rationale that cites lines the model never saw is a cheap and effective hallucination check.
If you sample several times per finding, record each answer; disagreement is a useful low-confidence signal.
④ Blind human labels: the ground truth you cannot skip
This is the expensive step, and the one teams most often fake. The labeller must not see the LLM verdict. If they do, you measure agreement with the model, not correctness. Use two reviewers per finding and adjudicate disagreements, as Tencent's own process does. Label "real" only when a reviewer can name the exploit precondition. Keep "cannot tell" as a separate label and exclude it from the metrics rather than guessing.
Split the labelled set. Use a training split for any few-shot examples or "memories" you feed back into the evidence pack (the dashed arrow in the diagram). Keep a test split the prompt has never seen. Mixing the two is the most common way we see teams report 99% accuracy.
⑤ Scorer: count what matters, with honest uncertainty
Score the judge against the human labels with a confusion matrix, then report four numbers per weakness class: share of false positives removed, share of real bugs kept (recall), precision of what is left in the queue, and cost and latency per finding. Report recall with a confidence interval, because the sample of real bugs is always smaller than you think. A minimal scorer:
import csv, math
def wilson(k, n, z=1.96):
if n == 0:
return (0.0, 1.0)
p, d = k / n, 1 + z * z / n
c = (p + z * z / (2 * n)) / d
h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d
return (c - h, c + h)
rows = list(csv.DictReader(open("labelled_findings.csv"))) # finding_id, cwe, llm_verdict, human_label
real = [r for r in rows if r["human_label"] == "real"]
false = [r for r in rows if r["human_label"] == "false_positive"]
kept = sum(r["llm_verdict"] != "false_positive" for r in real) # unsure counts as kept
removed = sum(r["llm_verdict"] == "false_positive" for r in false)
lo, hi = wilson(kept, len(real))
print(f"recall {kept}/{len(real)} = {kept/len(real):.1%} (95% CI {lo:.1%}-{hi:.1%})")
print(f"false positives removed {removed}/{len(false)} = {removed/len(false):.1%}")
print(f"queue precision {kept/(kept + len(false) - removed):.1%}")Run it per CWE as well as overall. QASecClaw's CWE-501 result shows that a filter can improve the average while making one class worse.
⑥ Routing policy: earn the right to suppress
The routing policy turns verdicts into actions; the scorer decides what it may do:
The never-suppress list covers the weakness classes where one miss is unacceptable for your product: injection into interpreters, authentication bypass, deserialisation and anything internet-facing. Everything else is a candidate, but only once the scorer shows recall above your target for that class. A 5–10% audit sample of suppressed findings goes back to blind labelling continuously. That is how you catch drift when the model, the prompt or your codebase changes.
What the numbers say
This is the chart vendors would show you, and it is real: every study reports a large cut, and hybrid methods cluster around 90%. The orange bar is the one to remember: in the same industrial dataset where LLM4PFA removed 94–98%, simple prompting removed 26–52%. How you build the evidence matters more than which model you pick.
This is our arithmetic on the Tencent study's Table 2, averaged across the four models and rounded. It is not new data, but it reframes the published figures as the queue your engineers would see. Without an LLM, they inspect 433 alarms to find 105 real bugs: 24% precision. Basic prompting shrinks the queue to about 281 but raises precision only to 28%, and it loses about 28 real bugs on the way. That is roughly the worst of both worlds. LLM4PFA shrinks the queue to about 98 alarms at 87% precision, which is transformative for workload. It still loses about 19 real bugs, nearly one in five. At 10–20 minutes per alarm, the reduction from 433 to 98 saves the reviewers roughly 55 to 110 hours. Whether that is worth 19 unexamined real bugs depends entirely on what those bugs are, which is why the routing policy works per weakness class.
This chart is the one most comparisons miss. Precision and false-positive rates depend on the base rate: how many alerts are real to begin with. In the OWASP Benchmark around 70% of alerts are real, because the benchmark was built to test scanners. In Tencent's labelled production data it was 24%, and below 10% once the paper's discarded alarms are counted. A judge that looks excellent on a 70%-real benchmark can produce a queue that is still mostly noise when 90% of the input is false. That is why the harness has to run on your findings, not on a benchmark.
The last chart is pure statistics, and the reason step ④ needs a budget. Recall is estimated only from findings that humans confirm as real. With 45 confirmed real bugs, the size of the LLM4PFA paper's set, an observed 85% recall has a 95% interval of roughly 72–93%. With 105, the size of the Tencent set, it is roughly 77–91%. You need around 300 confirmed real bugs to get within ±4 points. Per weakness class, you will rarely have that many. So the honest policy is conservative: suppress only in classes where even the lower bound is acceptable.
In a recent engagement…
We recently reviewed an LLM triage pilot for a European software company with a large Java and TypeScript estate. The AppSec team had connected a general-purpose model to its SAST pipeline with a short prompt: "Is this finding a false positive? Answer yes or no." The pilot dashboard showed a large drop in open findings, and developers loved it. The proposal on the table was to let the model auto-close findings across the board.
We asked how many of the closed findings a human had looked at. None, because the point had been to stop looking. So two of their engineers blind-labelled a sample of the auto-closed findings. Most closures were correct, and the developers' praise was deserved. But the sample also contained real injection findings that the model had closed with a confident, plausible rationale, citing a sanitiser that did not cover the sink in question. The model had not hallucinated code. It had applied a true fact to the wrong path.
The fix did not involve a different model. We kept the LLM, but moved it from deciding to advising. The prompt became an evidence pack with the scanner's dataflow trace and per-CWE guidance. Injection and authentication classes went on the never-suppress list. Suppression came back only for two noisy, low-impact rule families, each with a measured recall and a monthly audit sample. Developer satisfaction stayed high, because the rationale next to each finding was what had saved them time all along. The dashboard had measured open findings, not missed ones.
Decision table: what to let the LLM do
This is the screenshot-able part. Start in the top row and move down only when the evidence column is true for that weakness class.
| Mode | What the LLM does | Evidence you need first | Typical fit | Main risk |
|---|---|---|---|---|
| Explain | Adds a rationale and evidence lines to every finding; humans decide | None beyond a sanity check | All findings, from day one | Reviewers anchoring on a wrong rationale |
| Rank | Sorts the queue by verdict and confidence; nothing is hidden | Recall and precision measured on a labelled sample | Large backlogs, noisy rule packs | Low-ranked real bugs never reached |
| Suppress in PR, keep in backlog | Hides likely false positives from pull-request comments; AppSec still sees them | Recall above target for the CWE, lower CI bound acceptable | Medium- and low-severity classes with high noise | Drift after model or code changes |
| Auto-close | Closes findings with a stored, reversible rationale | All of the above, plus continuous audit sampling and an owner | Narrow, well-understood rule families only | Silent false negatives in shipped code |
| Never | Advisory only, regardless of scores | n/a | Injection, auth bypass, deserialisation, crypto misuse, internet-facing paths | n/a |
And the checklist we use before any mode beyond "Explain" goes live:
- Findings are de-duplicated with stable IDs that join verdicts to labels.
- The labelled set has a held-out test split the prompt and examples never touched.
- Labels are blind to the LLM verdict, with two reviewers and adjudication.
- Recall is reported per CWE with a 95% interval, and at least 100 confirmed real bugs in total.
- Model version, prompt hash, temperature and evidence-pack version are logged with every verdict.
- "Unsure" routes to humans, and rationales are checked for line numbers that exist.
- A never-suppress list exists, is owned by AppSec and is reviewed quarterly.
- A 5–10% audit sample of suppressed findings is labelled every month, and recall is re-computed on it.
- Every suppression is reversible and searchable, so a later incident can be traced back to the decision.
- Source code sent to the model stays within your contractual and data-residency limits.
Governance for European enterprises
LLM triage does not create a new regulatory regime. It changes how you evidence obligations you already have.
Cyber Resilience Act. Regulation (EU) 2024/2847 requires products with digital elements to be made available without known exploitable vulnerabilities (Annex I, Part I). It also requires manufacturers to identify, document and remediate vulnerabilities without delay (Annex I, Part II). The full obligations apply from 11 December 2027. The Article 14 duty to report actively exploited vulnerabilities and severe incidents has applied since 11 September 2026. A SAST finding that your scanner detected and an LLM suppressed is, in hindsight, a vulnerability you knew about. If it is later exploited, you will want to show the suppression rationale, the policy that allowed it and the recall measurement behind that policy. Our CRA 24/72-hour reporting runbook covers what happens next.
NIS2. Article 21(2)(e) of Directive (EU) 2022/2555 requires essential and important entities to manage security in network and information systems acquisition, development and maintenance, including vulnerability handling and disclosure. An auditor will accept automation. They will not accept a control that nobody measures. The harness output, recall per class with an audit trail, is the evidence.
EU AI Act. A tool that triages your own SAST findings is not a high-risk AI system: vulnerability triage is not among the Annex III use cases. The general-purpose AI model obligations sit with the model provider, not with you as a user. The practical duty for you is Article 4 AI literacy, which has applied since 2 February 2025: the people who rely on the verdicts need to understand their limits.
GDPR and confidentiality. Repositories contain credentials, test fixtures and comments with names. Sending evidence packs to an external model is a processing and confidentiality decision: check the provider's data-processing terms and retention, use EU-hosted endpoints where your policies require it, and strip secrets first.
A pragmatic adoption path
- Weeks 1–2: turn on "Explain" and start labelling. Add LLM rationales to findings without changing any workflow. In parallel, have two AppSec engineers blind-label a stratified sample of recent findings. Aim for 100+ confirmed real bugs across your top weakness classes.
- Weeks 3–4: build the evidence pack and the scorer. Feed the scanner's dataflow traces and per-CWE guidance into the prompt. Run the harness on the held-out split and produce recall per class with intervals. Compare your prompt with the vendor's built-in triage on the same data. Our AI agent evaluation harness guide covers the evaluation plumbing in more depth.
- Month 2: "Rank", then "Suppress in PR" for two noisy classes. Pick the two rule families with the most false positives and the lowest impact, and suppress them only in pull-request comments. Keep them in the backlog. Write the never-suppress list and get AppSec to own it.
- Month 3: audit loop and change control. Start the monthly audit sample. Treat any change of model, prompt or evidence pack as a release that must pass the harness again, just as you would gate a scanner rule change in your DevSecOps pipeline.
- Quarterly: widen or narrow. Add classes to suppression only when their lower recall bound clears your target, and remove them when audits show drift. Report the numbers next to your SBOM and VEX metrics; our SBOM and VEX operations guide applies the same funnel logic to dependency CVEs. If AI agents write the code being scanned, pair this with securing AI coding agents in the SDLC.
The verdict
Can LLMs triage SAST findings? Yes, better than the sceptics expected and less safely than the vendors imply. The 2026 evidence shows that a model given precise code context removes most false positives at a cost of seconds and cents per finding. Its explanations also cut human review time sharply. That is a real productivity gain, and refusing it means paying engineers to read noise.
The same evidence shows that every configuration loses real bugs, and that the loss is invisible if you only measure what was removed. Our position is simple. Use LLMs to explain and rank every finding now. Let them suppress only where you have measured recall on your own labelled code, per weakness class, with a confidence interval and an audit sample. Never let them close the classes that would end up in an incident report. The model is not the hard part. The labelled data and the routing policy are, and they are what an auditor will ask for.
If you want help building the harness or reviewing a triage pilot, our DevSecOps team runs this as a short, fixed-scope engagement. You leave with labelled data, recall per class and a routing policy you can defend.
FAQ
Can an LLM reliably decide whether a SAST finding is a false positive?
Not on its own, and not yet without measurement. In a 2026 industrial study at Tencent, simple prompting removed only 26–52% of false positives while dropping 16–38% of the real bugs. The best hybrid design, which gives the model precise code context and path constraints, removed 94–98% of false positives but kept only 75–88% of real bugs, below the 90% recall the authors describe as the enterprise expectation. Use the LLM to rank and explain findings, and let it suppress only where you have measured its recall on your own labelled data.
How much do LLMs reduce SAST false positives in published studies?
Published figures range from about 26% to 98%, depending heavily on method and dataset. Tencent's industrial study reports 94–98% for its best hybrid technique. QASecClaw reports 88.6% on the OWASP Benchmark, SAST-Genius about 91% on 25 open-source projects, and LLM4PFA 72–96%. These are self-reported on different datasets with different base rates, so they cannot be compared like for like. None of them is a prediction for your codebase.
What is the biggest risk of using AI to triage static analysis results?
Silent false negatives. When an LLM marks a real vulnerability as a false positive and the finding is auto-closed, nobody looks at it again. Headline false-positive reduction numbers hide this cost. Every study we reviewed that reports both sides shows some loss of real bugs, and the simplest prompting approaches lose the most. Measure recall with a confidence interval, keep a never-suppress list for critical weakness classes, and audit a sample of suppressed findings.
How many labelled findings do we need to evaluate an LLM triage tool?
Count real bugs, not findings. Recall is estimated only from findings that humans confirm as real, so the uncertainty depends on that number. With 45 real bugs and an observed recall of 85%, the 95% Wilson interval runs from about 72% to 93%. With 105 real bugs it narrows to about 77–91%, and you need roughly 300 to get within ±4 points. Most teams should start with 100+ confirmed real findings across the weakness classes they care about.
Do vendor AI triage features like Semgrep's or Datadog's replace this evaluation?
No. Semgrep documents its AI noise filtering as over 95% accurate at categorising findings as false positives. Datadog evaluated its Bits AI false-positive filtering on the OWASP Benchmark. Neither page publishes the method in enough detail to transfer the result to your code. Treat vendor figures as directional. Run the same harness against the vendor feature and your own prompt, on your own labelled findings, and compare recall first.
Does using an LLM to triage vulnerabilities create obligations under EU law?
The triage tool itself is not a high-risk AI system under the EU AI Act; it is not in Annex III. The obligations that matter come from what you build. The Cyber Resilience Act requires products with digital elements to ship without known exploitable vulnerabilities and requires documented vulnerability handling, and its Article 14 reporting duties have applied since 11 September 2026. NIS2 Article 21(2)(e) covers vulnerability handling in development. If an LLM suppresses a real finding, you need to show how that decision was made and checked.
Sources
All sources checked on 15 November 2026. Figures marked "our arithmetic" or "our analysis" in the charts are derived from the cited numbers or from standard statistics; we did not run any model for this article.
Tier A: primary research data, standards and regulation
- Du et al., "Reducing False Positives in Static Bug Detection with LLMs: An Empirical Study in Industry" (arXiv:2601.18844, 26 Jan 2026): https://arxiv.org/abs/2601.18844
- Regulation (EU) 2024/2847 (Cyber Resilience Act), Annex I and Article 14: https://eur-lex.europa.eu/eli/reg/2024/2847/oj/eng
- Directive (EU) 2022/2555 (NIS2), Article 21: https://eur-lex.europa.eu/eli/dir/2022/2555/oj/eng
- Regulation (EU) 2024/1689 (AI Act), Article 4 and Annex III: https://eur-lex.europa.eu/eli/reg/2024/1689/oj/eng
- OWASP Benchmark project: https://owasp.org/www-project-benchmark/
Tier B: research
- Iranmanesh et al., "ZeroFalse: Improving Precision in Static Analysis with LLMs" (arXiv:2510.02534): https://arxiv.org/abs/2510.02534
- Ameen, Alam and Islam, "QASecClaw: A Multi-Agent LLM Approach for False Positive Reduction in SAST" (arXiv:2605.01885): https://arxiv.org/abs/2605.01885
- Du et al., "Minimizing False Positives in Static Bug Detection via LLM-Enhanced Path Feasibility Analysis" (arXiv:2506.10322): https://arxiv.org/abs/2506.10322
- Agrawal and Ahi, "LLM-Driven SAST-Genius" (arXiv:2509.15433): https://arxiv.org/abs/2509.15433
- Chen et al., "Utilizing Precise and Complete Code Context to Guide LLM in Automatic False Positive Mitigation" (arXiv:2411.03079): https://arxiv.org/abs/2411.03079
- Lin, "LLM-Driven Adaptive Source-Sink Identification and False Positive Mitigation for Static Analysis" (arXiv:2511.04023): https://arxiv.org/abs/2511.04023
- Ullah et al., "LLMs Cannot Reliably Identify and Reason About Security Vulnerabilities (Yet?)", IEEE S&P 2024 (arXiv:2312.12575): https://arxiv.org/abs/2312.12575
- Ding et al., "Vulnerability Detection with Code Language Models: How Far Are We?", ICSE 2025 (arXiv:2403.18624): https://arxiv.org/abs/2403.18624
- GitHub Security Lab, "AI-supported vulnerability triage with the GitHub Security Lab Taskflow Agent" (20 Jan 2026): https://github.blog/security/ai-supported-vulnerability-triage-with-the-github-security-lab-taskflow-agent/
Tier C: vendor and commentary, directional
- Semgrep documentation, AI-assisted triage and noise filtering: https://docs.semgrep.dev/semgrep-assistant/overview
- Datadog, "Using LLMs to filter out false positives from static code analysis" (28 Oct 2025): https://www.datadoghq.com/blog/using-llms-to-filter-out-false-positives/
- InfoWorld, "How pairing SAST with AI dramatically reduces false positives in code security" (20 Nov 2025): https://www.infoworld.com/article/4093079/how-pairing-sast-with-ai-dramatically-reduces-false-positives-in-code-security.html
Topics