Vulnerability Remediation
The Vulnerability Remediation agent processes the dependency vulnerabilities your scanner reports. For each CVE, it decides whether the vulnerable code is reachable from your services. It finds every repository that carries the affected package. Then it opens a tested fix PR per repository, routed to the owning team. When no upstream fix exists yet, it files a mitigation ticket instead.
This page describes what the agent does at each stage of a run, what you configure, and what it produces.
How a run works
A run moves each finding through six stages.
- Intake
The agent reads open issues from your scanner. With Snyk, each issue carries:
- The CVE and CWE identifiers
- The CVSS score and effective severity
- Exploit maturity, when Snyk has assessed it
- Fixability signals (upgradeable, patchable, pinnable, fixable upstream)
- Available remedies
- Snyk's reachability result
A run starts on a schedule or on demand for a single CVE. The Snyk integration is read-only and has no webhook, so runs don't start from a Snyk event.
- Triage
The agent ranks findings by severity, exploit maturity and fixability. It weights them by the business criticality and environment recorded on the scanner project. As a result, a critical CVE in a production service is handled before a medium one in a sandbox. Findings below your severity threshold are skipped.
- Reachability
For each remaining finding, the agent checks whether your code can actually call the vulnerable function. It starts from the scanner's reachability data where it exists, then reads the call sites in the repository to confirm. A finding with no reachable path is recorded as not reachable, with the evidence, instead of producing a PR.
- Locate and route
The agent maps the vulnerable package to every repository, base image and Terraform module that carries it. It uses the scanner's project-to-repository mapping and the project's SBOM. Each repository is matched to its owning team through the Context Graph.
- Fix
In a sandbox, the agent clones each affected repository and tries the smallest upgrade that clears the CVE, described below. It regenerates the lockfile, runs the repository's tests, and checks the changelog for breaking changes.
- Deliver and verify
The agent opens one pull request per repository, assigned to the owning team, or a mitigation ticket when no fix exists. After the PR merges, it checks that the scanner's next scan no longer reports the finding. It then records the outcome in the finding's evidence trail.
Choosing the fix
The agent always tries the least disruptive upgrade first:
- Patch release of the current version, if one clears the CVE.
- Minor release, if no patch does.
- Major release, only if nothing smaller clears the CVE. Majors are the most likely to break the build. For this reason, the agent reads the changelog for breaking changes and records what it found in the PR.
For transitive dependencies, it upgrades the direct dependency that requires the vulnerable package. Alternatively, when the package manager supports it and the scanner reports the finding as pinnable, it pins the transitive version.
When the first repository's fix succeeds, the agent reuses that fix pattern for the other repositories that carry the same package. The pattern includes the target version, the pin and any code changes the upgrade needed. Later PRs therefore need fewer steps than the first.
What the agent produces
| Outcome | When | What you get |
|---|---|---|
| Fix PR | An upgrade clears the CVE and tests pass | A small PR with the version change, the regenerated lockfile, test results and the CVE it closes |
| Draft PR | An upgrade clears the CVE but tests fail | The same PR opened as a draft, with the failing tests and the relevant changelog entries attached, so an engineer starts from a diagnosis |
| Mitigation ticket | No upstream fix exists | A Jira ticket with the workaround, such as a config change or disabling the affected code path. The agent returns to the finding when a fix is published |
| Not reachable | No call path reaches the vulnerable code | A recorded decision with the evidence, visible in the run, with no PR |
Every PR and ticket links to the run, so a reviewer can see the triage decision, the reachability evidence and each command the agent ran.
Evidence trail and SLAs
Each finding has a severity-based SLA. The agent records every step from detection to a clean rescan:
- When the finding arrived
- The triage and reachability decisions
- The PR or ticket
- The merge
- The rescan that confirmed the fix
For regulated teams, this record can support audit evidence requirements such as those in PCI DSS, DORA or FFIEC. The record lives in the Audit Trail rather than being reconstructed before the audit.
Access and safety
- Sandboxed changes. Cloning, upgrading and testing happen in a sandbox on the built-in harness. The agent has no write access to your main branch. Every change reaches you as a PR, subject to your normal review and CI.
- Scoped tool access. The agent reads from the scanner and source control, and writes only what you grant: pushing a branch, opening a PR, filing a ticket. A governance policy on write operations pauses each of them for a person to approve.
- Models and budget. Each step routes to a model from your approved list, with a per-agent budget. The frontier model is reserved for steps such as reachability analysis and breaking-change review.
The agent runs in your isolated tenant (SaaS) or your own environment (BYOC), connected or airgapped. See Sovereignty.
How it improves
Upgrades teach lessons that are expensive to learn twice:
- Which major version broke a build
- Which pin fixed a lockfile
- What a changelog entry meant for your code
After each run, those lessons are captured as memories that later runs recall for the same package.
The Evaluator also scores each run against what happened downstream. Downstream signals include whether the PR merged without follow-up fixes, whether CI needed re-runs, and whether the rescan was clean. The Healer turns weak scores into context changes, such as a skill for a package manager's quirks, that an engineer approves.
Limits
- Reachability depends on what the agent can read. A vulnerable package reached through a repository you haven't connected, or through reflection or dynamic loading, can be judged not reachable. Connect every repository that ships to production, and treat "not reachable" as a decision with evidence to review, not a guarantee.
- Tests bound confidence. A fix PR is only as safe as the repository's test suite. A passing run on a repository with thin tests says little about a major upgrade, which is why majors carry the changelog review.
- Container and OS packages. Base-image vulnerabilities are fixed by updating the image reference. The agent doesn't rebuild images you don't build from source in a connected repository.
Integrations
| Integration type | Integrations | Used for |
|---|---|---|
| Scanner | Snyk | Findings, fixability, reachability, project-to-repo mapping and SBOMs |
| Source control | GitHub, GitLab | Reading code and manifests, pushing branches, opening PRs |
| CI/CD | Jenkins | Test results on the fix branch, when tests run in CI rather than in the sandbox |
| Issue tracking | Jira | Mitigation tickets |
| Collaboration | Slack, Microsoft Teams | Starting a run for a CVE and posting status to the owning team |
| Service ownership | Context Graph | Routing each PR to the team that owns the repository |
Get started
- Connect Snyk and confirm it lists your projects.
- Connect source control with a credential that can push branches and open pull requests. The GitHub integration's own tools are read-only. The agent pushes branches and opens PRs with
gitandghin its sandbox. For this reason, the connected credential needs Contents and Pull requests write permission. On GitLab, the integration includes branch and merge-request tools. - Populate service ownership in the Context Graph so fixes route to the right team.
- Set the severity threshold and SLA per severity. Add a governance policy that requires approval for write operations.
- Run the agent on one known CVE. Review the PRs, tickets and reachability decisions it produces before you put it on a schedule.