Deterministic SAST still matters as agentic code scanning expands

At a glance

What this is: Cycode benchmarked deterministic SAST against agentic code scanning and found that high-precision rules still matter, especially when paired with harnessed agent reasoning.

Why it matters: For IAM and security teams, the finding matters because access-control flaws and privilege enforcement bugs often evade simple rules, so code scanning strategy now affects identity governance, not just AppSec triage.

By the numbers:

• Cycode SAST reached 93.75% true positive rate with a 2.12% false positive rate on the OWASP Benchmark for Java.
• 80% of organisations report their AI agents have already performed actions beyond their intended scope, including accessing unauthorised systems, sharing sensitive data, and revealing access credentials.

👉 Read Cycode’s benchmark analysis of deterministic SAST and agentic code scanning

Context

Deterministic SAST is static, rules-based code analysis that checks source code for known weakness patterns, while agentic code scanning uses reasoning to inspect code paths and infer missing controls. The governance question is not whether one replaces the other, but how teams separate predictable enforcement from higher-cost analysis when vulnerabilities involve authorization, privilege boundaries, or business logic.

This article is about that operating model shift rather than a single scanner result. For identity and access teams, the relevance is direct wherever code enforces permissions, token scopes, or trust boundaries, because broken authorization often becomes an identity problem before it becomes a code quality problem.

Key questions

Q: How should security teams combine AI-native scanning with deterministic SAST for code review at scale?

A: Use deterministic SAST as the control for known vulnerability classes, especially OWASP Top 10 issues, because it is exhaustive, repeatable, and auditable. Use AI-native scanning to reason about missing context and business logic gaps such as authorization checks or ownership validation. The best operating model is layered, with rules first and AI second, so each tool covers the failure mode it handles best.

Q: Why do broken access control issues survive normal application security testing?

A: They survive because many tools look for patterns inside a single file or repository, while the failure often lives in how multiple functions or services enforce the same rule differently. If the analysis cannot trace where permissions are checked, dropped, or assumed, it will miss the actual control failure. That is especially common in distributed systems.

Q: What are the signs that an agentic code scanner is not well governed?

A: Look for inconsistent coverage, scans that spend time in irrelevant files, findings that cannot be reproduced, and output that overstates confidence without clear provenance. Those are signs the harness is weak, because the model may be capable while the workflow around it is not.

Q: How do teams decide when to trust rules versus reasoning in code analysis?

A: Trust rules for stable, expressible weakness patterns where precision matters and output must be identical across runs. Use reasoning when the defect depends on intent, missing policy enforcement, or multi-step context. If the vulnerability can be described as a simple source-to-sink pattern, rules usually belong first.

Technical breakdown

Why deterministic SAST still works at scale

Deterministic SAST evaluates code against fixed rules and data-flow paths, which gives it three operational advantages: consistency, speed, and low marginal cost. Cycode’s benchmark framing matters because false positives are not just an annoyance, they are a governance problem that erodes trust in the control. High-precision rules are especially effective when the vulnerability pattern is expressible as a source-to-sink relationship, such as user input reaching a dangerous call. That makes SAST a control plane for routine enforcement, not an expert system for every class of flaw.

Practical implication: Use deterministic SAST as the always-on baseline for findings that can be expressed as stable code rules.

Where agentic code scanning finds what rules miss

Agentic code scanning becomes valuable when the vulnerability depends on intent, context, or missing authorization logic that a fixed pattern cannot express. The article’s examples, including an admin endpoint with no permission guard and a scope check that stops one condition short, show why reasoning is needed for broken access control and business logic flaws. In practice, the model is not “smarter scanning” in the abstract. It is a different method for reconstructing whether code actually enforces the policy it appears to enforce. That distinction matters most in identity-sensitive code paths.

Practical implication: Reserve agent reasoning for authorization, privilege, and logic defects that rules cannot reliably describe.

Why the harness matters more than the model

A harness shapes what the agent inspects, in what order, and with what budget constraints. Without that orchestration, the model wastes effort on irrelevant files, misses vulnerable paths, and over-claims findings with more confidence than a rule engine. Cycode’s comparison between a harnessed open-weight approach and a higher-cost coding agent shows the core point: model size alone does not guarantee coverage or precision. Governance therefore sits above the scanner itself, deciding how findings are produced, recorded, and routed for review.

Practical implication: Control repository scope, scan order, and audit logging before you compare model performance.

NHI Mgmt Group analysis

Deterministic precision is still the security control that makes AI-assisted scanning usable. The article’s benchmark numbers show that noisy scanning is not just inefficient, it is governance failure by volume. In IAM-adjacent code, especially permission checks and token handling, teams need a baseline they can trust before they layer on agent reasoning. Precision is therefore a prerequisite for scaling review capacity, not a legacy preference.

Authorization bugs are the bridge between AppSec and identity governance. Broken access control is not merely a code smell. It is the point where application logic stops enforcing identity assertions such as who may act, under what scope, and with what privilege. That makes deterministic SAST necessary but incomplete, because rules detect patterns while governance depends on policy enforcement actually being present.

Harnessed agent reasoning is a workflow control, not just a detection method. The article shows that model performance depends on orchestration, file selection, and budget discipline. For the broader market, that signals a shift toward control planes that decide which analysis style to run for which class of defect. Practitioners should read this as evidence that code security is moving toward governed composition rather than single-tool supremacy.

AI security budgets will increasingly be judged on coverage quality, not model cost. A more expensive model that misses relevant files is operationally weaker than a cheaper model constrained by a good harness. The implication for security leaders is that procurement questions will have to move from “which model?” to “which analysis system, with what auditability, on which classes of risk?” That is the direction mature programmes should follow.

AI-driven code scanning creates a new audit expectation around reproducibility. If a review cannot explain what ran, on which repository, with which constraints, and why a finding was or was not generated, the control is difficult to defend. That expectation is especially important where code governs credentials, access checks, and delegated privilege. The practical conclusion is to make scan provenance a first-class governance requirement.

What this signals

Deterministic code analysis and agentic reasoning are converging into a single governance problem: how to prove which defects were scanned, why a finding was generated, and what class of risk was intentionally left to deeper analysis. For identity-heavy applications, that matters because access control logic is often buried in application code rather than managed centrally, which means security leaders need visibility into both policy enforcement and scan provenance.

Scan provenance debt: the gap between what the scanner can find and what the organisation can prove it actually inspected will become a board-level audit issue. As code analysis shifts toward model-assisted reasoning, auditability, reproducibility, and triage ownership become the controls that determine whether findings are defensible or merely persuasive. Teams should expect stronger scrutiny of how analysis decisions are recorded.

The practical direction is to treat AI-assisted scanning as a governed workflow inside the broader secure development lifecycle, not as a replacement for it. When code paths govern credentials, role checks, or privilege boundaries, the organisation needs explicit routing rules between deterministic and reasoning-based analysis, plus a clear handoff into remediation and review.

For practitioners

• Keep deterministic SAST as the baseline gate Run high-precision rules on every commit so routine authorization and data-flow issues are caught with consistent output before deeper analysis is needed.
• Route only rule-resistant findings to agentic review Use reasoning-based scanning for access control, business logic, and privilege enforcement defects that fixed patterns cannot express reliably.
• Instrument the harness, not just the model Log repository scope, file selection, scan order, and model choice so every run can be audited and reproduced later.
• Separate code analysis classes by risk type Map predictable weakness patterns to deterministic SAST and context-heavy authorization flaws to agentic scanning instead of asking one tool to do both jobs.

Key takeaways

• Deterministic SAST remains valuable because precision, not novelty, is what keeps large-scale scanning usable.
• Agentic code scanning is most useful where the defect is contextual, especially in access control and privilege enforcement.
• The real governance question is no longer which model to use, but how the scan harness proves coverage, provenance, and auditability.

Key terms

• Deterministic SAST: Static application security testing that returns the same findings for the same code and rule set. Determinism matters because teams use the output to gate releases, support audits, and compare changes over time without uncertainty introduced by probabilistic scoring or model drift.
• Agentic scanning: A security testing approach that blends deterministic analysis with AI-assisted reasoning and automated triage. It is designed for modern development environments where code volume, complexity, and delivery speed outpace purely manual review.
• Harness: The harness is the layer of instructions, policies, and approval logic wrapped around an AI agent. It is where organisations try to constrain behaviour, but it only works if the rules are explicit, current, and enforced outside the model itself.
• Broken Access Control: Broken access control occurs when a system fails to restrict what an authenticated user, service, or workload can do. The issue often appears as missing checks, inconsistent enforcement, or excessive permissions. It is a structural weakness because attacks exploit the gap between verified identity and permitted action.

What's in the full article

Cycode's full analysis covers the operational detail this post intentionally leaves for the source:

• The benchmark setup for the OWASP Benchmark for Java and the six-CVE repository set used to compare rule-based and agentic scanning.
• The exact harnessing approach Cycode used to steer cheaper open-weight models toward relevant files and away from noisy scan paths.
• The full four-dimensional code-analysis workflow, including AI exploitability review, agentic scanning, rule distillation, and remediation routing.
• The specific repository-level examples that show where deterministic SAST, agent reasoning, and audit logging each fit in the workflow.

👉 Cycode’s full post covers the benchmark design, the harness effect, and the four-dimensional workflow in detail.

Deepen your knowledge

The NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, machine identity security, and secrets management. It helps practitioners connect access control, lifecycle management, and operational governance across identity programmes.