Why JFrog

Every organization that ships software depends on binaries — internal builds, open-source packages, container images, and the third-party dependencies that flow through every pipeline. Without a central system of record, teams work from scattered registries and policies that make it difficult to enforce security policies, prevent third-party vulnerabilities, and know about and report on what is in the code being delivered to production.

JFrog Artifactory serves as the structural backbone of your software development process, providing one place to store, version, and govern what you build and what you consume, with end-to-end software supply chain management from the first dependency pull through release. Artifactory functions as your single source of truth, offering deep, immutable visibility into application components across every stage of the SDLC. By continuously tracking binaries from initial CI/CD builds through to live production environments, it establishes a reliable lineage that ensures software integrity, simplifies compliance audits, and accelerates troubleshooting.

Delivering Secure Solutions in the AI Era

AI-assisted workflows are accelerating development and widening the risk surface. Coding agents, IDE plugins, and autonomous tools pull packages and connect to external services with less visibility into what was requested or approved.

JFrog addresses intake and release in the same platform: JFrog Curation evaluates third-party packages before they enter your environment, while Package Traffic Controller ensures your developers don't bypass verification. Continuous scanning governs what is already inside. JFrog enables your organization to securely deliver AI tools to users — MCP servers, Agent Skills, and AI plugins — through the same repository and access models that govern traditional binaries. JFrog also provides its own JFrog MCP Server and JFrog Skills so you can connect coding agents, query artifact and vulnerability data, and run platform workflows from the IDE.

JFrog Supports You No Matter Your Role

One platform — multiple functions. The following accordions summarize what JFrog delivers for each role.

Developer

You write the code. JFrog seamlessly governs what you build it with — and what your AI coding agents pull on your behalf.

Once JFrog is set up in your organization and your package manager points at Artifactory, your day-to-day workflow stays the same. Governance, curation, and security run in the background while you code.

Common Pain Points

• Security scans block your build in CI with no context on whether the CVE is actually exploitable or which version fixes it.
• Your AI coding agent pulls npm or PyPI packages autonomously — with no visibility into whether those packages are approved or safe.
• You're told to use the internal registry, but it's unclear what's there, whether it's current, or how to point your package manager at it.

How JFrog Helps

• Your universal package manager (Artifactory) — proxies npm, PyPI, Maven, Go, Docker, and 60+ other ecosystems and enables you to transparently get on with your work while JFrog manages security and governance in the background.
• Seamlessly block risky packages at request time (Curation) — approved packages flow through instantly. Blocked packages surface a clear policy reason. No tickets, no waiting.
• Inline CVE context and one-click fix suggestions (Xray + Advanced Security) — exploitability analysis and remediation advice surface directly in your IDE and CI pipeline, without manually cross-referencing advisory databases.
• Artifact and vulnerability data just a question away (JFrog MCP Server + JFrog Skills) — You can query package metadata, scan results, and policy status using natural language from inside Cursor, Claude Code, or VS Code without leaving the IDE.
• A secure channel through which to proxy your coding agent's tool calls (Agent Guard) — proxies every call from your local AI agent through approved MCP servers, so agent-driven workflows stay inside your org's security perimeter.

DevOps / Platform Engineer

You own the pipeline. JFrog gives it a consistent governance layer, complete build lineage, and a single artifact store that works across every team and technology in your organization.

Common Pain Points

• Multiple teams use separate registries — Docker here, npm there, a shared S3 bucket for build outputs. No unified view, no consistent retention or access policy.
• A CVE surfaces weeks after a release and you have no fast way to know which builds used the affected dependency version.
• AI models, agent skills, and MCP servers are deployed but tracked in spreadsheets or ad-hoc Git tags — not versioned artifact stores with proper access control.

How JFrog Helps

• A single store for every artifact type (Artifactory) — replaces siloed registries across 60+ package formats with one access control model providing clear traceability while enabling you to define retention and audit activity.
• Complete build traceability from commit to binary (Artifactory Build Info) — every artifact carries the exact source commit, resolved dependency versions, and CI run that produced it. CVE impact queries become seconds, not fire drills.
• Codified promotion gates between environments (Release Lifecycle Management) — artifacts advance from dev → staging → release only when they clear your defined security and quality checks. Promotion history is immutable.
• Versioned artifact storage for AI and agent components (ML Repositories + MCP Registry + Skills Repositories) — brings AI models, MCP servers, and agent skill packages under the same infrastructure you already run for code artifacts.
• Native integration with your existing CI/CD toolchain (JFrog CLI + CI/CD integrations) — plugs JFrog's governance layer into GitHub Actions, Jenkins, GitLab CI, and others without rearchitecting your pipeline.
  

Security Engineer

You set the policy. JFrog enforces it automatically at every layer — before packages enter, and continuously on everything already inside.

Common Pain Points

• You learn about a compromised package after it's already in three builds. The fix is a fire drill because you don't know all the places it landed.
• AI coding agents pull dependencies autonomously, outside your existing security tooling. You have no visibility into what they're consuming.
• Models are downloaded from Hugging Face and used in production. Nobody has scanned them for malicious payloads or checked whether they're approved.

How JFrog Helps

• Preventive blocking of malicious packages before ingestion (Curation) — dependency confusion attacks, typosquatting, and known-malicious packages are stopped at the point of request, before they touch your environment.
• Continuous re-evaluation of existing artifacts (Xray) — When a new CVE is published, existing artifacts and historical releases are automatically re-evaluated, ensuring they never become silent liabilities.
• Exploitability filtering to cut alert noise (Advanced Security) — call graph analysis determines whether a vulnerable function is actually invoked in your code, so your team acts on real risk instead of theoretical exposure.
• Secrets, IaC, and SAST scanning across the pipeline (Advanced Security) — exposed credentials in artifacts, Terraform misconfigurations, and code logic vulnerabilities caught at the same stage as dependency risk.
• Inventory and scanning of unauthorized AI models (Shadow AI Detection + Malicious Model Detection) — surfaces unmanaged AI assets and scans public-registry models for hidden payloads before they're cached internally.
• Policy enforcement on every agent tool call (Agent Guard) — centralizes control over what actions local AI agents can take through approved MCP servers, with a full audit trail.

Release Manager

You own the release. JFrog gives you the audit trail, the promotion controls, and the distribution infrastructure to ship trusted software confidently.

Common Pain Points

• Releases are promoted manually with no enforced checklist. A vulnerability in a shipped release is traced back to a step that was skipped under deadline pressure.
• Generating an SBOM or compliance artifact for a release means chasing down data from multiple systems — build logs, dependency files, scan reports — by hand.

How JFrog Helps

• Automated, policy-enforced promotion gates (Release Lifecycle Management) — nothing advances to the next environment without clearing defined security, quality, and compliance conditions. No manual checklist, no skipped steps.
• Automated SBOM generation per build (Xray) — every release artifact carries a complete Software Bill of Materials generated automatically from build info, ready for regulatory or customer delivery.
• Immutable release bundles with cryptographic signing (Distribution) — package a verified set of artifacts into a signed release bundle and distribute it at scale to any target environment, including edge and air-gapped deployments.
• Full audit history for every promotion and distribution event (Artifactory) — who approved it, when, from which build, with which dependencies. Available on demand for compliance review or incident response.

System Administrator

You keep the platform running. JFrog gives you the access control, deployment flexibility, and operational tooling to manage it at enterprise scale.

Common Pain Points

• Access control is inconsistent across registries — different permission models for Docker vs npm vs Maven, no central view of who has access to what.
• The organization spans multiple regions and clouds. Keeping artifact availability consistent without stale caches or replication lag is a constant operational challenge.

How JFrog Helps

• Unified RBAC across all repository types (Artifactory) — one permission model for every package format. Manage users, groups, and access tokens from a single admin surface, with SSO and SCIM integration.
• Multi-site replication and federated repositories (Artifactory) — keep artifact availability consistent across regions and cloud providers with configurable replication policies and federated repository sync.
• Flexible deployment: cloud, self-managed, or hybrid (JFrog Platform) — run on AWS, Azure, or GCP as a managed SaaS service, or self-manage on your own infrastructure. Same platform, same feature set, either way.
• Centralized audit logging and operational monitoring (Artifactory + Mission Control) — full audit trails for every access and administrative action, with integrations to Splunk, Datadog, and other observability platforms.

JFrog Artifactory — Artifact Management and Your System of Record

Artifactory is the universal artifact repository manager at the heart of the JFrog Platform. It's where every binary your organization produces or consumes is stored, versioned, and traced — the foundation that Curation, Xray, and the AI capabilities all build on.

Artifact Management

Artifactory securely hosts, indexes, and manages all binaries, packages, and container images used across the organization. It provides development teams with automated version control, local caching for speed, and centralized access to both open-source and proprietary dependencies to ensure consistent and reliable builds.

Build Info, CI/CD Integration, and SDLC Visibility

Build Info captures the exact source commit, dependency versions, and CI/CD pipeline run for every artifact Artifactory stores — integrating with GitHub Actions, Jenkins, GitLab CI, and other tools through the JFrog CLI and platform plugins. SBOMs and scan results attach to the same binaries, so composition and security data travel with the artifact from build through release. In production, continuous scanning and real-time security monitoring keep visibility on what's actually deployed — so when a new vulnerability emerges, you can trace impact across the SDLC, not just at build time.

Repository Maturity and Promotion

Artifacts move through defined repository stages — dev → staging → release — only when they pass the security and quality gates you've configured. Promotion is codified, not manual. Every promotion event is recorded and auditable.

Software Supply Chain System of Record

Artifactory immutably binds every stage of the development lifecycle into a verifiable chain of custody, ensuring absolute trust and compliance from code to production. This unified platform guarantees complete regulatory traceability by natively incorporating Immutable Build Records (Build Info), Automated reporting via SBOM, a verifiable chain of evidence for compliance, and the Trust Layer for AI and Agentic Workflows.

AI Asset Management

JFrog extends the same supply chain principles to AI models, agent tooling, and ML workloads — discover and allow models in JFrog AI Catalog, govern MCP servers your agents call, and build and deploy custom models with JFrog ML.

JFrog AI Catalog — Governed Model Management

AI Catalog gives your organization a single place to discover, approve, and consume AI models — model packages, external APIs, and custom uploads — under the same governance model as traditional binaries. The Registry lists models allowed for use. Discovery lets admins review and approve candidates. Detection surfaces unmanaged models already in your artifacts through Xray-powered shadow AI detection. Each model is scanned for vulnerabilities with transparent license information before it enters your supply chain. Curation settings gate model packages from Hugging Face and other providers so only vetted models can be cached and used.

Get Started with AI Catalog

MCP Registry — Govern the Tools Your Agents Use

The MCP Registry is a versioned, policy-enforced system of record for MCP servers — the tool endpoints coding agents call during development. Register pre-built or custom servers, configure tool-level allow and deny policies, and connect local agents through Agent Guard so every tool call routes through your approved server list. The same access and audit patterns that govern npm packages and container images apply to the agent tooling your teams rely on.

MCP Registry overview

JFrog ML — Build, Deploy, and Monitor Models

JFrog ML extends the platform for teams that develop and operate their own machine learning models — not just consume approved ones from the catalog. Build and train models, manage versions, and deploy to real-time, batch, or streaming endpoints with inference analytics and runtime monitoring. Model artifacts stay connected to Artifactory and AI Catalog, so the lineage from training through production reflects the same traceability your application releases already depend on.

JFrog ML overview

AI Repositories — Plugins, Extensions, and Skills

Artifactory AI repositories extend the same storage, access control, and promotion model to the artifacts coding agents and AI-native IDEs consume every day. Agent Plugins repositories store and distribute plugins across agent harnesses — including marketplace files for Claude, Cursor, and Codex. AI Editor Extension repositories proxy extension marketplaces so VS Code, Cursor, and other IDE plugins are curated before developers install them. Skills repositories version agent skill packages as governed artifacts, with scanning at upload time — closing the gap between governing models and MCP servers and governing the tooling that runs inside the IDE.

Curation — Prevent Vulnerabilities from Entering Your Binary Ecosystem

Most security tools scan artifacts after they've been downloaded. Curation intercepts package requests before anything is stored in your repositories — blocking what doesn't meet your policy before it ever touches your environment.

How It Works

When a developer or pipeline requests a third-party package, Curation evaluates it against your organization's policies before it's cached into Artifactory. Approved packages: transparent, zero-latency delivery. Blocked packages: immediate explanation to the developer — no ticket, no manual review queue.

What Policies Can Check

• CVE severity thresholds — block packages that exceed your defined CVSS limit
• Malicious package detection — cross-referenced against JFrog Security Research threat intelligence
• License restrictions — block GPL, AGPL, or licenses incompatible with your IP policy
• Operational risk — unmaintained packages, very new packages with no release history, unknown publishers
• Dependency confusion — packages whose names match internal components but originate from public registries

Beyond Traditional Packages

Curation's scope extends to IDE extensions and AI model downloads — not just npm or PyPI. Developers pulling VS Code plugins or Hugging Face models can be governed through the same policy layer as any other dependency.

Package Traffic Controller — Governance at the Network Layer

Not every developer in a large organization will update their package manager to point at Artifactory. Package Traffic Controller (PTC) closes that gap. By integrating with SASE infrastructure (Zscaler ZIA), PTC intercepts and reroutes outbound package requests at the network level — redirecting them through Artifactory and Curation before they reach any public registry.

This means Curation policies apply to every request passing through your organization's secure edge — from developers, AI users, and AI agents — regardless of whether the developer configured their tooling correctly, or at all.

Security Scanning and Compliance

Curation is your first gate. JFrog Xray and Advanced Security run continuously on everything already inside — scanning artifacts, containers, and AI models, and re-evaluating them automatically as new threats emerge.

JFrog Xray — Continuous Artifact Scanning

JFrog Xray conducts deep dependency analysis across every artifact in Artifactory, including transitive dependencies (the downstream packages and binaries pulled in by third-party dependencies). Scanning is ongoing — when a new CVE is published, existing artifacts are re-evaluated automatically. Last quarter's release doesn't become a silent liability.

Advanced Security — Contextual Exploitability

Not every CVE in your dependency tree is reachable in your application. Advanced Security adds call graph analysis to determine whether a vulnerable function is actually invoked — cutting alert volume to what your team needs to act on, including:

• SAST — source code scanning for logic vulnerabilities
• Secrets detection — exposed API keys, tokens, and credentials in artifacts and containers
• IaC scanning — Terraform, Helm, and CloudFormation misconfiguration
• Contextual analysis — exploitability scoring based on actual code paths

Policies, Watches, and Automated Enforcement

Define security, license, and operational policies in Xray and attach them to repository watches. When a violation is detected, actions trigger automatically — block a download, fail a build, send a webhook, generate a violation report. Policy enforcement doesn't rely on someone remembering to run a scan.

AppTrust — End-to-End Oversight for Your Releases

Curation and scanning control what enters your environment and what risks exist in your binaries. AppTrust carries that posture through to release — automating governance, risk, and compliance so delivery stays fast without manual checkpoints at the end of the pipeline.

Built-in Delivery Governance

AppTrust integrates governance, risk, and compliance directly into how your teams build and ship software, automating policies and controls continuously across the SDLC instead of treating compliance as a post-development gate. Define lifecycle policies, create and promote application versions through defined stages, and release with confidence that policy evaluations and evidence support the decision. Waiver workflows document exceptions when a promotion fails — without losing traceability.

For more information, see:

• Get Started with Governance & Lifecycle
• AppTrust Overview

Evidence — Creating a Signed Audit Trail Across the SDLC

JFrog Evidence Collection gathers signed attestations from across your pipeline — build outputs, scan results, and integrations with commonly used SDLC tools — to form a comprehensive audit trail. Evidence ties back to the same artifacts in Artifactory that Curation and Xray already govern, so auditors and release managers can answer what went into a release and who approved it.

Release Lifecycle Management

Release Lifecycle Management enables you to package verified artifacts into signed Release Bundles, promote versions through your environments, and distribute to production or edge targets — including air-gapped deployments. Combined with Xray SBOMs and vulnerability reporting, your team gets actionable insight into the security posture of every application version before it ships.

How It Connects

AppTrust, Evidence, Release Lifecycle Management, and AI Catalog build on the same Artifactory artifacts, Xray scan results, and catalog metadata that Curation and security scanning already use — one platform from dependency intake through trusted release and governed AI assets.

Next Steps

These are the most common starting points, depending on what you're setting up first.

Related Topics

• Set up Artifactory
• Configure Curation
• Enable Xray Scanning
• Get Started with AI Catalog
• Get Started with Governance and Lifecycle