JFrog Advanced Security and Safeguard both try to answer the question every vulnerability list leaves open: of the thousands of vulnerabilities, which ones can actually hurt this application? They answer it differently. JFrog's Contextual Analysis uses scanners written by JFrog's security research team for individual high-profile CVEs, tied into Xray and Artifactory, and it sits beside secrets detection, SAST, infrastructure as code checks, malicious package detection and Frogbot pull request scanning. Safeguard's reachability analysis builds a static call graph from source, lockfiles and bytecode, produces a priority score from reachability, exploit likelihood, asset context and business context, and then opens a policy-gated fix pull request. As of 17 Nov 2026, JFrog is a natural fit if your estate is built around Artifactory and you scan compiled binaries and container images as much as source. Safeguard is worth a serious look if you want exploitability, code scanning, fixes, policy gates and compliance evidence in one vulnerabilities model, and you are happy to treat your artifact manager as a separate decision. Plenty of teams will run both.
Every fact about JFrog below comes from JFrog's own documentation, pricing page or repositories, with the URL and the access date of 17 Nov 2026. Every fact about Safeguard comes from Safeguard's documentation and pricing page. Where a page did not cover a point, this post leaves it out instead of guessing. JFrog's documentation has moved to docs.jfrog.com, and that is where the links point.
Related reading: JFrog Xray alternatives in 2026, the JFrog Xray deployment blueprint and JFrog vs Sonatype vs Safeguard. This post is narrower than those: it compares the Advanced Security layer, and the Xray base it builds on, with Safeguard's equivalents, capability by capability.
Key takeaways
- Xray is the base, Advanced Security is the add-on. Xray indexes artifacts and enforces policy on Artifactory. Per JFrog's docs, Advanced Security "is available as an add-on with the Enterprise X or Enterprise+ subscription" and adds Contextual Analysis, secrets, SAST, IaC, malicious package detection and binary analysis.
- JFrog's exploitability verdicts come from per-CVE scanners. The documentation cites more than 1,600 high-profile CVEs, with scanners built by JFrog Security Research, and about one third of scanners use configuration, flags or host properties instead of reachability.
- JFrog's SAST matrix is wide. It names C and C++, C#, Go, Java, JavaScript, Kotlin, Python, Rust, Terraform and TypeScript.
- Safeguard's reachability is general-purpose. Static call-graph analysis applied to every vulnerability, with four reachability classes and a 0 to 100 priority score.
- Both vendors say static analysis has limits. JFrog returns Undetermined. Safeguard marks reflection and similar cases unknown and treats them conservatively.
- Fix workflows differ. Frogbot opens dependency upgrade pull requests, and JFrog's pricing page also lists Agentic Remediation and Zero Touch Remediation. Safeguard's Griffin opens policy gated pull requests with breaking-change tiers, singly or in bulk, and your own CI checks each one.
- Safeguard adds fixed artifacts. Gold Registry and fork-and-patch address the case where upstream has no fix. See the Fix it without waiting for upstream section.
How JFrog's security products fit together
JFrog sells several security capabilities, and the names overlap in conversation. A short map, from JFrog's documentation:
| Capability | What it does | Where it runs |
|---|---|---|
| Xray | Software composition analysis of artifacts, builds, release bundles and images, with watches and policies that generate violations | Integrated with Artifactory |
| Curation | Gates open source package downloads through Artifactory remote repositories | Artifactory download path. See our JFrog Curation guide |
| Advanced Security (add-on) | Contextual Analysis, secrets, IaC and misconfiguration, SAST, malicious package detection, binary analysis | IDE, CLI, pull requests through Frogbot, CI, Artifactory, release bundles |
| Frogbot | Scans source and dependencies in pull requests and can open fix pull requests | Source control and CI |
| JFrog Runtime | Production monitoring: whether vulnerable code is loaded into memory, integrity violations, untrusted registries | Production. A separate requirement from Advanced Security |
The Advanced Security page lists where scans run: the developer environment (SAST and dependency scans in IDEs and the CLI), source control (Frogbot on pull requests), CI/CD pipelines (builds, including contextual analysis, secrets and misconfigurations), Artifactory repositories (continuous scanning, policy enforcement, malicious package detection and artifact integrity verification), release bundles (scanned before promotion or distribution) and production through JFrog Runtime (Advanced Security overview, accessed 17 Nov 2026).
That list is worth reading as an architecture. JFrog is strongest where the artifact is the unit of control: a binary, an image or a release bundle moving through Artifactory repositories toward production. It follows the artifact from the developer's machine to the repository to the release.
Xray: the base layer
Xray is described in JFrog's documentation as software composition analysis natively integrated with Artifactory. The mechanics matter to anyone comparing it with a source-first scanner.
Indexing. Binary scanning in Artifactory works on indexed repositories. Once a repository is indexed, Xray keeps a dependency graph for each scanned artifact and reuses it when new vulnerability data arrives. Xray can also import CycloneDX or SPDX SBOMs for scanning.
Watches and policies. Watches and policies decide what happens when a scan result matches a rule. Matching rules create violations, and policy actions can block downloads, fail builds or block distribution, and notify teams by email, Slack, webhooks or Jira.
Local, pull request and CI scans. Developers can scan source and manifests in IDE plugins or with jf audit, and local binaries with jf scan or jf docker scan. In CI, JFrog recommends a Frogbot repository scan for source before the build, jf scan or jf docker scan for binaries and images before upload, and jf build-scan for published builds (scan types, accessed 17 Nov 2026). Release bundles are scanned before promotion or distribution.
Continuous monitoring. When new vulnerability or malicious package data arrives, Impact Analysis finds which indexed artifacts are affected, updates their scan reports and re-evaluates matching policies, including when a CVE's CISA KEV status changes. On SaaS it runs about every hour. It covers indexed resources whose scan retention period is current (continuous monitoring, accessed 17 Nov 2026).
This is a mature and well-understood model for organizations that treat the artifact repository as the system of record. Two consequences follow. In Artifactory, the unit of analysis is the indexed artifact, and source is covered by the IDE, CLI, Frogbot and CI scans described above. And enforcement actions (block a download, fail a build, block distribution) are artifact-lifecycle actions, which suit release engineering well.
Advanced Security, capability by capability
Contextual Analysis
JFrog describes Contextual Analysis as flagging only CVEs that are exploitable in the scanned artifact, by checking first-party code usage, binary compilation, configuration, invocation and the runtime environment (Contextual Analysis of CVEs, accessed 17 Nov 2026). Several details in the documentation are worth reading closely.
- It is scanner-per-CVE. The scanners are built and maintained by JFrog Security Research. Prioritisation favours technologies common among JFrog customers, mainly high and critical CVEs (CVSS 7.5 and above, with ML-based severity prediction for CVEs that have no CVSS score), and CVEs exploited in the wild or with high media attention. The page cites more than 1,600 high-profile CVEs. If a CVE lacks a scanner, the research team prioritises building support for it, and with an Advanced Security subscription you can request research.
- It goes beyond reachability. Scanners can combine reachability, binary symbols and strings, configuration parsing, command-line flags and runtime environment checks. About one third of scanners deliberately work from other evidence, because for some CVEs it lives in config files, CLI flags or host properties. That is a real strength: some vulnerabilities are conditional on configuration, not on a call path.
- Every result carries a justification listing the signals the scanner checked.
- The statuses are explicit. Applicable, Not Applicable, Undetermined (static analysis cannot decide, for example when exploitation needs user interaction), Not Scanned, Rescan Required, Not Covered (scanner not available), Technology Unsupported, Missing Context (scanning the artifact in a Docker repository in the platform can resolve it) and Upgrade Required (for self-managed Xray, which must be upgraded to get a new scanner, then rescanned).
- Transitive analysis shows the chain. The Contextual Analysis tab shows direct and transitive views, with the call chain, a call graph, highlighted functions, file paths and copyable evidence such as line numbers. The pricing page lists Transitive Contextual Analysis under Enterprise +.
- Results appear in the Scans List, inline in the IDE, in the CLI and as pull request decoration through Frogbot.
What this means in practice: for the CVEs JFrog has a scanner for, you get a curated verdict with reasons, produced by researchers who looked at that specific vulnerability. For a CVE outside the researched set, the status is Not Covered and the vulnerability is ranked by its other signals. How much of your backlog lands in each bucket depends on your dependency mix, and that is the number to measure in a trial. The "1,600" figure is JFrog's description of its high-profile set, not a claim about coverage of every CVE in your tree.
Secrets detection
JFrog describes secrets detection as preventing accidental exposure of API keys, passwords and tokens. Its supported technologies page shows secrets detection for C and C++, C#, Go, Java, JavaScript, Kotlin, Python, Rust, Terraform and TypeScript, and for the images a Helm chart deploys (supported technologies for Advanced Security, accessed 17 Nov 2026). The Advanced Security page places secrets detection in the developer stage and in CI builds, and the docs also cover custom secrets scanners and dynamic token validation. For a team that stores binaries and images in Artifactory, that puts secrets checks close to where artifacts live.
SAST
The SAST component scans first-party code using cross-file semantic analysis, covering areas such as database access, external connections and OS commands, with remediation guidance. JFrog states that "Scans run locally, so they don't send source code outside the environment". For regulated buyers that is an important sentence, and it is worth confirming how it applies to your deployment.
Infrastructure as code and misconfiguration
The page lists checks of applications, services and IaC for insecure configurations. The supported technologies page gives the detail: Terraform modules in JFrog IDE plugins and the CLI, Terraform state files in Artifactory's Terraform backend repository, and application and service misconfigurations for container images in Artifactory. For Helm and Helm OCI charts, Xray scans the container images the chart deploys.
Malicious package detection and binary analysis
Advanced Security lists detection of malicious packages, typosquatting and package impersonation, and analysis of compiled binaries for flaws that source scanning alone would not show. The first sits alongside Curation, which gates packages at download. The second is a distinctive strength: if you ship compiled artifacts, uber JARs or container images and want vulnerabilities at that level, JFrog's model is built for it.
Frogbot
Frogbot is JFrog's pull request and repository scanner. Its documented commands include frogbot scan-pull-request, which compares project state before and after a change and reports only new issues as pull request comments, and frogbot scan-repository, which scans a branch's latest commit and, when fixable issues are found and Auto-PR is enabled, opens a pull request with the dependency upgrades (Frogbot documentation and the Frogbot repository, accessed 17 Nov 2026). Setup needs the JFrog platform URL, a platform access token and a Git provider token. Settings such as which scanners run, Auto-PR behaviour and pull request decoration can be managed centrally in the JFrog Platform, and local settings take precedence when both exist.
What the language matrix says
JFrog's matrix changes over time, so check it against the live page. As read on 17 Nov 2026 ("Not listed" means the cell is empty on that page):
| Language | SAST | Contextual Analysis (source) | Contextual Analysis (binary) | Secrets |
|---|---|---|---|---|
| C and C++ | Yes | Not listed | Inside Docker | Yes |
| C# and .NET | Yes | Yes | Inside Docker | Yes |
| Go | Yes | Yes | Inside Docker | Yes |
| Java | Yes | Yes | Maven and Gradle uber, fat and thin JARs | Yes |
| JavaScript and TypeScript | Yes | Yes | Inside Docker | Yes |
| Kotlin | Yes | Not listed | Inside Docker | Yes |
| Python | Yes | Yes | Inside Docker | Yes |
| Rust | Yes | Not listed | Inside Docker | Yes |
| Terraform (IaC) | Yes | Not listed | Not listed | Yes |
| Helm and Helm OCI | Not listed | Not listed | Images the chart deploys | Images the chart deploys |
Two patterns to note. Source-level Contextual Analysis is listed for six language families, and binary-level analysis for most languages is listed as inside Docker, with Maven and Gradle JARs as the Java route. JFrog documents how to package applications in Docker for Contextual Analysis. If your deployment unit is already a container image, that is natural. If it is not, ask JFrog what the workflow looks like for you.
Safeguard's equivalents
Reachability and prioritisation
Safeguard's prioritisation engine ranks vulnerabilities from four signals: reachability, exploitability (EPSS and CISA KEV, plus public proof-of-concept availability), asset context and business context (reachability docs, accessed 17 Nov 2026). Safeguard positions this as cutting the urgent queue by roughly 60 to 80 percent, and the documentation notes that the effect depends on your code, languages and environments, so measure it on your own estate.
- Static reachability builds a call graph from source, lockfiles and bytecode and checks whether any path reaches the vulnerable sink.
- Four classes: reachable, conditionally reachable (a path exists but needs a feature flag, route or configuration that is not currently enabled), unreachable and unknown. Unknown vulnerabilities are marked conservatively as potentially reachable.
- A 0 to 100 priority score from CVSS, EPSS, KEV, proof-of-concept availability, reachability, environment, exposure, data sensitivity and business criticality, with default bands (reachable plus KEV plus production is P0) and weights you can change per tenant.
- Policy integration: reachability feeds guardrails, so a production policy can block reachable, KEV-listed vulnerabilities.
- Griffin on top: once a vulnerability is prioritised, Griffin can propose a minimum-risk upgrade, explain why a vulnerability was de-prioritised for an exception review, and open pull requests for the top priorities on a schedule.
The documentation is candid about where static analysis is weakest: reflection, eval or unsafe dispatch (marked unknown and never suppressed), data-driven vulnerabilities, and code paths that run only under configurations the analyzer cannot enumerate. In those cases it advises relying on KEV, EPSS, asset context and conservative defaults. That is the same honesty JFrog shows with its Undetermined status, and it is the right posture from both vendors.
SCA and Package Firewall
Safeguard's SCA reads manifests and lockfiles for npm, pnpm and Yarn, PyPI, Maven and Gradle, Go modules, Cargo, NuGet, Composer and Ruby Bundler, plus components inside container image layers, and matches against CVE and GHSA advisories enriched with EPSS and KEV, and shows the full transitive path from your project root to the vulnerable package with its reachability verdict (SCA docs, accessed 17 Nov 2026). Package Firewall blocks malicious, typosquat and dependency confusion packages at install time for npm and pip. License governance is part of the same model.
SAST and DAST
Safeguard's SAST traces untrusted input from source to dangerous sink across functions and files, needs no build, and returns a vulnerability with a dataflow trace, CWE and OWASP mapping, severity and code location. It runs in your pipeline or on a local or on-prem runner, so source can stay inside your perimeter. The docs list JavaScript and TypeScript, Python and Java for SAST (application security testing docs, accessed 17 Nov 2026). Safeguard also documents DAST against verified targets, with allow-listed scope, rate limits, non-destructive defaults and an audit trail, and API security testing from a URL, OpenAPI file, curl command or Postman collection. SAST, DAST and SCA vulnerabilities share one model with correlation keys, so a DAST-confirmed issue can be linked to the SAST sink behind it and prioritised with it.
Policies and gates
Safeguard policies evaluate SBOMs and generate vulnerabilities, and gates enforce them. Conditions include severity, CVSS, EPSS, license, component age, maintenance state and SLSA level, with templates, a visual builder and YAML. In CI, safeguard ci scan --wait --fail-on-gate <gate> fails a job when the gate fails. Actions are block, warn or notify, and exceptions follow a request with justification, expiry and approval, with an audit trail (policies and gates docs, accessed 17 Nov 2026).
Fix pull requests
Safeguard's AI Remediate uses Griffin to analyse the vulnerability and codebase, pick the safest upgrade path, assess breaking changes and open a pull request, and your own CI runs on that pull request like any other, so your tests, builds and required checks decide whether it can merge. It handles dependency upgrades (including transitive conflicts, with the lockfile updated in the same pull request for npm), configuration fixes such as security headers and insecure defaults and, in some cases, code modifications. It can fix one vulnerability, a selected set (one pull request per repository) or every fixable vulnerability from the vulnerabilities page after you approve a plan. Settings control autonomous remediation and the fix strategy, and auto-merge is off by default, so your branch protection and required reviews apply. Fixes come in three tiers, compatible, minor and major, and a major upgrade is flagged for review. Supported ecosystems include npm, Yarn, pnpm, pip, Poetry, Pipenv, Maven, Gradle, Go modules, Cargo, Bundler, NuGet and Composer (auto-fix docs, accessed 17 Nov 2026).
Side by side
| Question | JFrog Xray and Advanced Security | Safeguard |
|---|---|---|
| Unit of analysis | Indexed artifacts in Artifactory, plus source in IDE, CLI, CI and pull requests | Repositories, SBOMs and projects, plus container image layers |
| Exploitability method | Per-CVE scanners from JFrog Security Research, combining reachability, binary symbols, configuration, flags and environment | Static call-graph reachability with a conditionally reachable class, plus EPSS, KEV and context in a priority score |
| Coverage statement | More than 1,600 high-profile CVEs, with a Not Covered status outside that set | General analysis applied to every vulnerability, unknown treated as potentially reachable |
| Uncertain results | Undetermined, Missing Context, Not Covered | Unknown, handled conservatively |
| Binary and image analysis | Strong: binaries, uber JARs, Docker and OCI images in Artifactory | Components in container image layers through SCA |
| Contextual Analysis source languages | C#, Go, Java, JavaScript, TypeScript, Python | Not applicable (general reachability) |
| Secrets | Listed languages, plus images a Helm chart deploys | Not covered in this comparison |
| SAST languages | C, C++, C#, Go, Java, JavaScript, Kotlin, Python, Rust, Terraform, TypeScript | JavaScript, TypeScript, Python, Java |
| IaC | Terraform, plus image misconfigurations in Artifactory | Not covered in this comparison |
| Pull request scanning | Frogbot, new issues only | Policy gates and CI scan with fail flags |
| Fix pull requests | Frogbot dependency upgrades when Auto-PR is on, plus Agentic and Zero Touch Remediation on the pricing page | Griffin pull requests checked by your CI, breaking-change tiers, single and bulk |
| Runtime | JFrog Runtime, separate requirement | Not part of this comparison |
| Artifact repository | Artifactory is the platform | Separate. Scanners accept Artifactory and binaries, container registries and SBOMs as inputs |
| Compliance evidence | Automated policy enforcement in the Advanced Security docs, evidence collection features on the pricing page | Compliance suite with evidence and frameworks in the same platform |
| Source | JFrog docs and pricing page, accessed 17 Nov 2026 | Safeguard docs, accessed 17 Nov 2026 |
How the verdicts differ, and why that matters
The two exploitability designs are not interchangeable, and the difference is worth stating carefully.
A per-CVE scanner can encode exactly what makes one vulnerability exploitable: a specific function call, a flag, a configuration file entry, a compile option. When JFrog has written that scanner, the result can be precise, and the justification shows its work. The trade-off is scope. JFrog's research focuses on high-profile, high and critical CVEs and those exploited in the wild, and a CVE outside that set shows Not Covered until a scanner is built. JFrog says building missing scanners is a priority and that Advanced Security subscribers can request research.
A general call-graph engine does not depend on someone having written a scanner for each CVE. It asks one question for every vulnerability in a supported language: is there a path from your code to the vulnerable function? That gives broad, uniform coverage across a long tail of lower-profile CVEs, provided the advisory identifies the affected code. The trade-off is precision where exploitability depends on something other than a call path, and on dynamic features such as reflection. Safeguard handles that with a conditionally reachable class, the EPSS, KEV and context signals in the priority score, and an unknown class that is never suppressed.
So the practical comparison is by population. On the high-profile CVEs, JFrog's curated verdicts may be hard to beat. On the long tail, a general engine is designed to return a reachability class for every vulnerability in your tree. A fair evaluation counts both: take your last 200 vulnerabilities and classify each as correct, wrong or no verdict for each product.
Where things run, and where your code goes
For regulated buyers, where the scan runs is part of the decision. JFrog states that SAST scans run locally so source code stays in the environment, and its pricing page offers both SaaS and self-managed plans. Safeguard's SAST and scans run in your pipeline or on a local runner, which pulls the repository on your machine, scans there and pushes only encrypted results. Safeguard deploys as SaaS, in a private VPC or on-prem. Its AI features can run in full AI mode, with your own model, with models inside your environment, or in a Zero AI mode where the platform runs deterministically with no LLM in the loop. Safeguard is SOC 2 Type I and Type II audited. Ask JFrog the same questions about each component you plan to buy, because the answer can differ between SaaS and self-managed.
Fix workflows compared
Detecting a vulnerability is the easy half. Frogbot gives developers the right place to see a result, on the pull request, and can open dependency upgrade pull requests, and JFrog's pricing page lists Agentic Remediation and Zero Touch Remediation for its higher tiers. Safeguard's Griffin grades breaking-change risk in three tiers, can open configuration and code changes as well as version bumps, works across repositories in bulk, and leaves your own CI and branch protection to decide what merges. The difference to test is what happens when a naive upgrade breaks the build. Pick ten vulnerable dependencies with a fixed version available and let each product open its pull requests, then count how many pass CI without human edits. That number, more than the feature list, is what your team will feel.
When no fixed version exists yet, Safeguard's answer is the Gold section further down.
Price and packaging
JFrog's pricing page, read on 17 Nov 2026, shows the plans below (jfrog.com/pricing). Prices on that page change, including limited time offers, so read it on the day you buy.
| Plan | Deployment | Price shown | Notes on the page |
|---|---|---|---|
| Pro | SaaS | "$150 / Month" struck through, "$50 / Month" labelled Limited Time Offer | 25 GB base consumption |
| Enterprise X | SaaS | Starting at $950 / Month | 125 GB base consumption, Unified Security and Ultimate Security packages |
| Enterprise + | SaaS | Custom pricing | Contact JFrog |
| Pro X | Self-managed | Starting at $27,000 / Year | 1 server, 24/7 SLA support |
| Enterprise X | Self-managed | Starting at $51,000 / Year | 3 servers, 24/7 SLA support |
| Enterprise + | Self-managed | Custom pricing | 6 servers |
On the page's own wording: Artifactory is included in every plan. The Enterprise X and Enterprise + descriptions list Code and Binary SCA, JFrog Advanced Security (contextual analysis, SCA, leaked secrets detection, Runtime Integrity, SAST, misconfigurations and IaC scanning) and JFrog Curation, and the page marks some items as optional add-ons. The Advanced Security documentation says it "is available as an add-on with the Enterprise X or Enterprise+ subscription". Enterprise + also lists Transitive Contextual Analysis, Agentic Remediation and Runtime Impact. Additional SaaS consumption is billed per GB in tiers, and storage and data transfer count toward monthly consumption. The total for the stack in this comparison is a quote conversation.
Safeguard prices on a different unit. See safeguard.sh/pricing for current plans. The pricing page says every plan carries every feature, and plans differ in included usage such as fix pull requests and components scanned each month. When you compare, ask what each quote includes: JFrog's SaaS consumption is tied to storage and data transfer, and Safeguard's plans are tied to scan and fix volume, so the better value depends on your artifact volume and how much you scan and fix. Read both pages on the day you buy.
When to choose JFrog Advanced Security
Choose it when Artifactory is already the backbone of your delivery pipeline and you want security to follow the artifact from developer to production. Choose it when you ship compiled binaries, uber JARs and container images and want exploitability analysis at that level, when you want secrets and SAST across a broad language list including C, C++, Go, Rust and Kotlin, and when you value a research team writing per-CVE scanners with a justification for each verdict. It also suits organizations that want Curation, Xray, Frogbot and runtime monitoring from one vendor and one contract.
When to choose Safeguard
Choose Safeguard when you want exploitability, SAST, DAST, SCA, policy gates, fix pull requests and compliance evidence in one vulnerabilities model, and your artifact manager is a separate decision or you have none. Choose it when you want a reachability class and priority score for every vulnerability in your tree, when you want fix pull requests with breaking-change tiers across the major package ecosystems, checked by your own CI, and when you want hardened Gold artifacts to start from. It also suits teams who need the platform in a private VPC or on-prem, with a Zero AI mode and bring-your-own-model option, and teams who want the same platform to drive SOC 2 and other framework evidence.
When to run both
Many organizations will keep Artifactory and Xray as the artifact system of record and add Safeguard for prioritisation across source, fix pull requests and compliance. If you do, decide which product is authoritative for each decision: JFrog for what may be promoted or distributed from Artifactory, Safeguard for what a developer fixes first. Feed one into the other with exports and tickets instead of asking developers to reconcile two backlogs.
Fix it without waiting for upstream
Whatever the vulnerability, most of the risk sits in two gaps. The first is the time between a fix being published and that fix actually running in your production builds. The second, and worse, is the time before any fix exists at all, while a maintainer works out a patch and a release schedule. Waiting through both gaps is a habit, not a requirement. Safeguard gives teams three ways to close them.
1. Autonomous remediation: pull requests, not tickets
When a fixed version exists, Griffin, Safeguard's security model, opens a policy gated pull request that moves the affected dependency to the safe version, and your own CI runs your tests on it before anyone merges. You can run it on one repository or in bulk across every project that carries the vulnerable version. Remediation categories include dependencies, licenses, security posture and findings, and each one is set separately. Reachability analysis ranks the vulnerable code paths your application actually calls first, so the first pull requests you merge are the ones that matter most. Auto-merge is a separate switch and stays off by default, so your team decides what merges on its own and what still needs a human approval.
2. Gold Open Source: the safe version in seconds, free
gold.safeguard.sh is free and needs no login. Search any CVE or package to see affected and fixed versions, CVSS, EPSS, CISA KEV status and a recommended safe version, or use the "Am I affected?" checker. The same data is available through a free read API, README status badges and RSS threat feeds.
3. Gold Registry: start from components that are already fixed
Safeguard Gold rebuilds patched versions of open-source packages and images from source, signs each build, attaches an SBOM, SLSA provenance and VEX, and serves them from registry.safeguard.sh to your organization. Every Gold artifact is held continuously to zero exploitable critical or high CVEs and a completed license check, with signed build provenance (signed with Safeguard's key and verifiable with cosign, SLSA Build Level 3 as the design target) and a public evidence page you can hand to an auditor. An artifact loses its Gold badge if it regresses. Teams can point their own package directory at the registry so hardened equivalents resolve without changing how developers install anything.
When upstream has no fix yet, or will not ship one, Safeguard first works to get the fix accepted upstream. If the issue is severe or upstream will not move, Safeguard builds a fork, fixes the vulnerability there and publishes a hardened Gold build, so you are not stuck on a maintainer's release schedule. You can also request a hardened build of a specific package. Ask which packages it covers before you plan around it.
| Your situation | What to use |
|---|---|
| A fixed version exists | Autonomous remediation opens the upgrade pull request; Gold Open Source confirms the safe version |
| You need to know today whether you are affected | Gold Open Source lookup and "Am I affected?" checker, free and without login |
| You want vulnerable versions to stop shipping | Safeguard policies and gates in CI |
| Upstream has no fix yet, or will not ship one | A custom Gold request; fork and patch |
| You want to start clean on new projects | Pull hardened components and images from Gold Registry |
One honest limit: when the vulnerable code lives in a vendor appliance, a hosted service or an operating system runtime you do not build yourself, the fix still has to come from that vendor or distribution. The steps above apply to the open source dependencies and container images you build and ship, which is where most teams carry the largest and least tracked share of their exposure.
Evaluation checklist
Use this list for a two-to-four week bake-off of JFrog Advanced Security, Safeguard, or both.
- Pick a representative sample. Five repositories across your main languages, plus one container image and one compiled artifact you ship.
- Record the entitlements. For JFrog, write down which plan, which add-ons and which Xray version. For Safeguard, the plan and the features enabled.
- Build the ground truth. Take your last 200 open vulnerabilities and have an engineer label each as exploitable, not exploitable or unknown. This is the dataset the products are scored against.
- Score exploitability verdicts. For each product count correct, wrong and no verdict, separately for high-profile CVEs and the long tail. Count how many vulnerabilities land in Not Covered, Undetermined or Unknown.
- Read three justifications. JFrog shows the signals each scanner checked. Safeguard shows the path. Judge whether a reviewer could confirm the verdict from the evidence alone.
- Test configuration-dependent CVEs. Pick a CVE that is exploitable only with a certain flag or setting, and see whether each product notices.
- Test secrets on the JFrog side. Plant harmless test secrets in source, in a config file, in an image layer and in git history, and see what JFrog finds, where and how fast. Compare it with the secrets tool you already run.
- Run SAST on a known-vulnerable app. Use your own test application and compare vulnerabilities, false positives and the quality of the remediation guidance in your languages. Check your language list against each vendor's current docs.
- Check IaC. Run each tool on the Terraform you actually use and ask both vendors for the rule coverage list.
- Measure the fix. Let each product open pull requests for ten fixable dependencies. Count how many pass CI untouched, how many need edits, and how many break something.
- Test the no-fix case. Choose a vulnerability with no fixed version. What does each product offer beyond a ticket?
- Check where code goes. Confirm, per component and per deployment model, whether source leaves your environment.
- Test the evidence path. Trace one vulnerability from detection to fix to an auditor-ready record, including who approved an exception.
- Cost it in writing. Get a quote for the full stack you would run, including add-ons and runtime, and a quote for the same scope from Safeguard.
Migration and coexistence notes
Nothing about Safeguard requires you to leave Artifactory, and nothing about Advanced Security requires you to stay. If you add Safeguard, connect your source control, run it in advisory mode beside Frogbot for a few weeks, and compare vulnerabilities and pull requests on the same repositories. If you consolidate onto Safeguard for code and dependency scanning, keep Artifactory as the artifact store, move policy intent (what may be promoted, which severities block) into Safeguard policies and gates, and keep Xray watches on the repositories where release engineering depends on them until you are satisfied. Keep the exception history from JFrog, so audit continuity is preserved.
FAQ
What does JFrog Advanced Security include?
According to JFrog's documentation, it is an add-on with Contextual Analysis of third-party CVEs, secrets detection, infrastructure as code and misconfiguration scanning, SAST, malicious package detection and binary analysis, with Frogbot for pull requests. JFrog Runtime for production monitoring is a separate requirement. Source: JFrog documentation, accessed 17 Nov 2026.
Is JFrog Advanced Security included in Xray?
It is an add-on. The Advanced Security documentation says it "is available as an add-on with the Enterprise X or Enterprise+ subscription". It builds on Xray: per the docs, Advanced Security enhances Xray's results by performing contextual analysis on third-party dependencies. Ask JFrog for a written quote that lists each component. Source: JFrog documentation and pricing page, accessed 17 Nov 2026.
What is Contextual Analysis in JFrog?
It checks whether a CVE in a third-party dependency is exploitable given how your code, binary, configuration and environment use it. Results are Applicable, Not Applicable, Undetermined or one of several coverage statuses, with a justification. Scanners are written by JFrog Security Research, and the documentation cites more than 1,600 high-profile CVEs covered. Source: JFrog documentation, accessed 17 Nov 2026.
Which languages does JFrog Contextual Analysis support?
For source code, JFrog's matrix lists C#, Go, Java, JavaScript, Python and TypeScript. Binary analysis is listed inside Docker for most languages, and for Java it covers Maven and Gradle JARs. The matrix changes over time, so check the live page. Source: JFrog documentation, accessed 17 Nov 2026.
How is Safeguard reachability different from JFrog Contextual Analysis?
Safeguard builds a static call graph and applies it to every vulnerability, with a conditionally reachable class, then produces a priority score with EPSS, KEV and context. JFrog uses per-CVE scanners built by its research team, about a third of which work from configuration, flags or host properties instead of reachability. The first generalises across many CVEs. The second can be very precise for the CVEs it covers. Source: both vendors' documentation, accessed 17 Nov 2026.
Does Safeguard have SAST and DAST?
Yes. Safeguard documents SAST that traces source-to-sink dataflow for JavaScript and TypeScript, Python and Java, and DAST against verified targets with safety controls, plus API security testing. Compare language lists against the current docs. Source: Safeguard documentation, accessed 17 Nov 2026.
Can Safeguard open fix pull requests the way Frogbot does?
Yes. Griffin opens pull requests that move dependencies to a safe version, assesses breaking changes, lets your own CI check each one, and can work on one vulnerability or in bulk. Frogbot can also open dependency upgrade pull requests when Auto-PR is enabled. Source: both vendors' documentation, accessed 17 Nov 2026.
Can I use Safeguard with Artifactory?
Yes. Safeguard scanners accept Artifactory and binaries as an input, Package Firewall checks npm and pip installs, and Safeguard provides vulnerabilities, fixes and evidence beside Artifactory.
What does each vendor cost?
See the price section above. JFrog's page shows starting prices for several plans and consumption rates, and Enterprise + and some add-ons are priced by quote. For Safeguard, see safeguard.sh/pricing for current plans.
Sources and access dates
All pages were accessed on 17 Nov 2026. Vendor facts change, so verify anything you plan to rely on. JFrog: Advanced Security, Contextual Analysis of CVEs, supported technologies for Advanced Security, scan types, continuous monitoring, scanning commits and pull requests, the Frogbot repository and the pricing page. Safeguard: reachability, application security testing, SCA, auto-fix, policies and gates, CI/CD, pricing and Gold.
JFrog, Artifactory, Xray, Frogbot and Curation are named here in plain text for comparison. This post does not imply any partnership with or endorsement by JFrog, and JFrog has not reviewed it.