drj logo
drj logo

Welcome to DRJ

Already registered user? Please login here

Create new account
(it's completely free). Subscribe

x

Why Security Pipelines Need Both AI and Deterministic Controls

AI: Automation & InnovationCyber Resilience & IT Disaster RecoveryData Protection: Backup & RecoveryGovernance: Compliance & Regulatory ReadinessOnline Exclusive
Why Security Pipelines Need Both AI and Deterministic Controls

Triaging vulnerability submissions is one of several responsibilities I have, and it is easily the most time-consuming. Over the past two years, my intake queue has grown roughly 5.5 times, and almost none of it involves researchers finding new bugs. The increase comes from customer scanners, software bill of materials ingestion, the growing adoption of continuous vulnerability management in regulated accounts, and inquiries about third-party components we ship.

Scanners are the easy version of this problem because they can only surface what somebody has already catalogued. AI and large language models (LLMs) have reduced the cost of code generation and vulnerability discovery while shortening the window between disclosure and the development of a working exploit. Attackers only have to be right once. Defenders have to answer for everything, and most of the answering turns out to be judgment work.

The objection is fair. The conclusion is wrong.

The first pushback is always the same: LLMs are non-deterministic, so how can you put one anywhere near a security control?

It is a reasonable question, but determinism isn’t accuracy. A scanner that reports the same false positive every run is perfectly reproducible and perfectly wrong. You need deterministic reproducibility for governance, audit, and regression testing, and it’s entirely different from correctness.

Another point worth noting is our entire security program already relies on non-deterministic components. Two analysts triaging the same vulnerability will produce different severity calls, different exploitability assessments, and different remediation advice. We do not respond to these inconsistencies by refusing to employ analysts. We respond with peer review, documented methodology, evidence requirements, and escalation paths. The same approach applies to AI models, and most of these practices transfer directly.

Deterministic systems decide. Non-deterministic systems reason.

This is the split that has held up for us.

Deterministic tools handle processes requiring defensible results: component identification through software composition analysis (SCA), version matching against common vulnerabilities and exposures (CVEs), and policy gates in continuous integration (CI). These tools produce consistent results, operate within defined rule sets, and generate findings auditors can review.

Non-deterministic tools handle labor-intensive tasks that can accommodate additional review: threat modeling, attack surface enumeration, initial vulnerability triage, evaluating whether vulnerable functions are reachable in a call path, and drafting customer advisories. These are judgment tasks where a knowledgeable human was already the bottleneck.

The practical version: put the model on the inputs and outputs of your deterministic pipeline, not in place of it. Let it help you decide what to scan and how to configure the scan. Let it help you understand and prioritize what came back. Keep the scan itself reproducible and keep the gate decision on the deterministic side of the line.

Making non-determinism manageable

You cannot eliminate variance. You can engineer around it, and the controls are not exotic.

Ground every claim in a specific artifact, line, log entry, or advisory. Require the model to state its confidence when it reaches a conclusion, and to say “insufficient evidence” rather than invent an answer. An ungrounded claim is not a finding.

Use disagreement as a routing signal. Run the same task several times. Consistent answers mean you can move fast. Divergent answers require human review, helping identify where additional attention is needed.

Treat models and prompts like dependencies. Pin them, version them, and log inputs and outputs so you can explain why a finding was deprioritized eight months ago.

Evaluate before you trust. Build a labeled set from cases you have already closed and measure the model against known-correct answers. This is the step that is often skipped, and it is the only one that tells you whether any of the rest is working.

What this looks like in my intake queue

The dominant item in my intake is not a product defect. It typically involves a customer scanner flagging a third-party component we ship and prompting two questions: Is it exploitable in your product, and when will it be fixed?

The first half is deterministic and always has been. Component identification, version resolution, and CVE matching are reproducible, auditable, and boring. They should stay exactly that way.

The second half is where the hours went. Whether the vulnerable function is reachable in our call path. Whether our configuration exposes it. What the customer should do before the patch lands. How to say all of that in a form they can act on without a follow-up thread. That is judgment work, and it was never reproducible because a human analyst was producing it.

The old process involved copying and pasting between spreadsheets, then handing the remaining 60% to 80% of the analysis to research and development (R&D) because there was limited time to finish it. Engineers then performed costly reachability analyses on their own components, often concluding the vulnerability was "not exploitable here."

That ratio has roughly inverted. Approximately 60% to 70% of inquiries are now answered before reaching research and development. Nothing about the deterministic half of the pipeline changed. The difference is the judgment work now receives an evidence-based initial assessment, which the analyst reviews and corrects instead of starting from scratch.

Two caveats, because they matter more than the number. Volume grew over the same period, so this is not a story about a quieter queue. The approach succeeds because of the controls described in the previous section rather than the model itself: every claim is tied to a specific artifact, unknowns are acknowledged rather than filled in, and results are measured against previously resolved cases before the model is used on live inquiries.

The greatest efficiency gains come from labor-intensive judgment work — threat modeling, attack surface mapping, triage, and patch impact analysis — rather than processes that already produce consistent results.

The tooling is the easy part

Buying before piloting. Evaluate a representative sample of your portfolio, measure the actual cost per repository or finding, and use those figures in negotiations. Otherwise, you could exhaust your annual budget after covering only 10% of your portfolio, with little to show for it because per-unit AI costs scale differently from those of licensed tools.

No governance. Productivity gains and governance are the same project. Without clear rules governing where data can be shared, sensitive material may end up in unapproved tools, with the exposure discovered only afterward.

Ignoring the model supply chain. Model marketplaces are becoming attractive targets for poisoned and backdoored artifacts. Treat models as dependencies: inventory what is in use, control where it can be pulled from, default to deny, and scan what you bring in.

Securing our world

My queue is still growing. What makes that survivable is not that the answers got faster. It is that the reproducible half of the work stayed reproducible, and the judgment half stopped requiring a specialist to start from nothing every time.

None of this requires waiting for the non-determinism problem to be solved. It requires identifying which decisions must be reproducible, which require judgment, and how to design a pipeline that accommodates both.

Share what worked, because that is the part the security community has always been good at.

ABOUT THE AUTHOR

Ben Ronallo

Ben Ronallo serves as director of cybersecurity operations at Black Duck, bringing more than 10 years of cybersecurity experience focused on protecting customer and employee data while navigating today's rapidly evolving threat landscape. His leadership approach centers on creating adaptive security frameworks that enable rather than hinder innovation, empowering employees to work effectively and securely while maintaining robust protection measures that scale with emerging threats and business growth. Ronallo specializes in building security-aware environments where teams can pursue innovation with confidence. He recognizes that successful cybersecurity programs integrate with business objectives to support security and organizational success.

Latest News
DRJ HOT ITEMS
Webinar Spotlight
Fetching Upcoming Webinars...
Journal Categories

AI: Automation & Innovation

Business Continuity Management

Crisis Management & Emergency Response

Cyber Resilience & IT Disaster Recovery

Leadership: Culture & Workforce Resilience

Operational Resilience

Risk Management & Quantification

Sector-Specific & Critical Infrastructure Resilience

Supply Chain & Third-Party Resilience

Governance: Compliance & Regulatory Readiness

Incident Management & Response Coordination

Resilience Strategy & Program Maturity

Data Protection: Backup & Recovery

Exercises: Testing & Scenario Planning

Emerging Threats: Geopolitical & Climate Risk

Contact Us

Newsletter

The Journal, right in your inbox.