Agentic AppSec: Snyk Evo and Your CI Pipeline

Agentic AppSec from Snyk Evo brings AI code security and vulnerability remediation agents to your CI pipeline and application security program.

A developer and a security engineer in a modern office talking at a desk with a laptop, a notebook, and a coffee mug, with natural light from a window.

Intro

Coding agents write code faster than any review process designed around human authors can absorb. Snyk published a figure in October 2026 that captures the gap: roughly eight new vulnerabilities introduced for every one remediated. That ratio is worth sitting with. If it holds even loosely across a normal engineering team, the triage queue stops being a queue and starts being an archive.

Agentic AppSec is Snyk’s answer to that imbalance, and the interesting part is what it is not. It is not another scanner sitting beside the one you already pay for. It is a set of agents meant to carry out the work an application security program does by hand, from assessing threats and controls through detection, prioritization, remediation, and independent verification of the proposed fix. The announcement (opens in new tab) is explicit that the answer is the program run by agents, with your team still owning policy and approvals.

Most people reading this already have a Snyk step somewhere in a pipeline. Maybe it is snyk test in a GitHub Actions workflow, maybe a Jenkins stage that fails the build above a severity threshold, maybe a GitLab CI job that opens a merge request with the findings. The question I keep coming back to is not whether agents are impressive. It is whether the gate moves, and where it lands.

What follows looks at that specifically. I am working through the three-layer model Snyk describes, what each of the named agents is claimed to do, what the VulnBump benchmark does and does not tell you about your repository, and the decisions a team has to make out loud before any of this does useful work. I have run Snyk in CI on my own boxes and in client pipelines, and I have watched dependency scanning fail for reasons that had nothing to do with the scanner.

One note on sourcing before we go further. The supply chain numbers Snyk cites, more than 20 high-profile attacks in 2026 and growth heading past 600% year over year, are the figures I would want to verify somewhere independent before repeating them in a budget conversation. The architectural argument stands without them, and it is the part that affects your pipeline this quarter.

Background: how the pull request scan became the whole strategy

The assumption underneath almost every CI security setup I have worked on is the same one. A change arrives as a pull request written by a person. The diff is small enough that someone understands it. A scanner reads that diff, pushes findings into a queue, and a human decides what matters. Everything downstream, the severity thresholds, the .snyk policy file, the “fail the build on high” stage in Jenkins, was built for that shape of work.

It fitted the delivery model fine when humans were the bottleneck. Ten pull requests a week meant ten small diffs and a queue you could actually drain. The scan ran at the end of the process because the human review was already at the end of the process. The gate sat next to the merge button because that is where the last checkpoint happened to be.

What that model never handled well is depth. Snyk’s own description of the problem is that the in-depth reviews which catch business logic flaws and broken access control take so much time and context that most teams run them once, for a handful of critical applications, and then stop. I have been on that side of it. Someone pays for a proper review of the payments service, the report arrives, a few tickets get filed, and the twelve other applications in the estate never get the same treatment because nobody can fund a repeat.

So the queue fills with what the pattern-based scanners can see, which is known vulnerability signatures and exposed secrets, and quietly ignores the class of flaw that actually causes the breaches people remember. You end up with a green pipeline and an application where a user can change an account ID in a URL and read someone else’s invoice. The scanner did its job. The job was just narrower than the dashboard suggested.

The part worth stating plainly is that this backlog predates coding agents by years. Flooded queues, noisy findings, latent risk nobody has the hours to look at, all of that was already true when a human typed every line. AI-generated code makes the pressure worse and makes the queue longer, but it did not create the gap between what a diff scan can see and what an application actually does. If anything, that distinction matters for how you read the rest of Snyk’s argument.

What’s happening now: agentic AppSec as a three-layer model

The reason a pull request scan cannot be the only control comes down to timing. When npm install runs on a CI runner, every dependency’s lifecycle scripts execute as part of the install, before the test step and before the scan step is even scheduled. A postinstall hook sitting in a compromised transitive package runs with the runner’s environment in scope, which on most hosted runners means a cloud token, a registry token, and whatever secrets the job was handed. The scan reports the package as malicious, and somebody rotates credentials on Monday morning. No diff ever had to be read for that to happen.

Snyk’s answer is to stop treating application security as a single checkpoint and split it across three places: checks inside the coding workflow where the agent is generating code, fast deterministic scans on every change in CI, and deeper analysis of the whole application on a regular schedule rather than per-commit. Those three run at different speeds for a reason, and the split is what keeps pipeline latency from being set by the slowest job in the chain.

The agent set maps onto those stages:

  • Evo Agentic Security Review works at the application level, mapping threats and controls and producing findings with evidence attached. This is the depth of review most teams can currently only afford once.
  • Evo Code Scanning Agent targets business logic and authorization flaws, the change-the-ID-in-the-URL class of bug that signature scanners do not catch.
  • Snyk Secrets watches for exposed credentials across both hand-written and AI-assisted work.
  • Evo Remediation Agent proposes fixes, starting with third-party dependency upgrades.
  • Evo Dependency Firewall blocks malicious or out-of-policy packages at install time, sitting between the package manager and the registry rather than downstream of the build.

The two supply chain figures in the announcement are the ones I would want to verify independently: more than 20 named high-profile attacks in 2026, and growth on track to exceed 600% year over year. The 600% has no stated baseline, and year-over-year growth in a category where tracking only recently got serious is easy to inflate. The direction of travel is not in dispute. The precision is.

What agentic AppSec means in practice for your CI pipeline

The gate moves. Most teams today treat the pipeline as the place where a change gets judged, so the control point sits near the end, in the scan step that decides whether the merge is blocked. A dependency running a postinstall script is already past that gate by the time it fires. If you have watched npm install pull a tarball that reads the environment and posts it off-box, you know the scan never got a turn. Putting policy between the package manager and the registry, which is what Evo Dependency Firewall does, changes the failure mode from “we merged a compromised lockfile” to “the install refused.”

VulnBump is the part of the announcement with a number attached, and it reads as a statement about workflow more than detection. Evo Remediation Agent produced mergeable fixes 90% of the time, against 59.6% for the same model without Snyk context. Mergeability is the metric that matters. A fix that closes the CVE and breaks the build gets reverted inside the hour, and the vulnerability returns wearing a commit message that says it was intentional. Finding count tells you nothing about that, which is why I care more about the 30-point gap than about either headline figure. It is still a benchmark on Snyk’s own test set, and your lockfile churn is not that test set.

The harder work is the policy conversation that was previously implicit. Four questions need answers in writing: what gets blocked outright, what gets fixed and committed automatically, what waits for a human, and who signs off on the acceptance criteria for an agent-authored change. I have sat through enough of these to know the fourth question is the one nobody volunteers to own, and it is the one that decides whether any of this reduces your backlog or just adds a second queue next to the first.

My expectation, stated as an expectation rather than a fact, is that install-time blocking becomes default in most CI templates within a year while the merge gate stays roughly where it is. The scan step does not disappear. It stops being the only thing standing between you and a bad package.