JFrog AppTrust and DevGovOps: Continuous Compliance for the AI-Era Software Supply Chain

On September 2, 2026, at swampUP 2026 in New York, JFrog unveiled DevGovOps for the AI era: a new class of capabilities in JFrog AppTrust that automates governance across the entire software supply chain. The backdrop is blunt. Coding agents are writing code at superhuman speed, sometimes fully autonomously, and traditional periodic compliance reviews can no longer keep up. At the same time, regulations are tightening rather than relaxing: the EU Cyber Resilience Act and NIST-related requirements are pushing harder compliance deadlines. JFrog's answer is not more reports. It is turning regulations into rules that execute at build time and shrinking audit prep from weeks of manual evidence gathering to hours of queries.

1. The Problem DevGovOps Attacks

JFrog's vice president, Haggai Schechtman, put it directly: agents run around doing things you did not ask them to do, because their job is to achieve the goal, not to follow your process. When they pull dependencies, edit code, and open pull requests, organizations lose control over how they did it and what they brought in. Meanwhile the law has not relaxed for AI. The Cyber Resilience Act requires products to ship without known exploited vulnerabilities and to include an SBOM, and NIST guidance keeps tightening. DevGovOps reframes governance from a single pre-release check into a continuous process embedded in every build and every artifact.

# Compliance as code: express the EU Cyber Resilience Act
# (CRA) and NIST guidance as plain-language, enforceable rules.
policy = {
  "name": "cra_essential_security",
  "applies_to": ["*"],
  "rules": [
    {
      "id": "no_known_exploited_vulns",
      "check": "artifact.vulns.known_exploited == []",
      "action": "block_build",
      "reason": "CRA Art. 13: products must ship without known exploited vulnerabilities"
    },
    {
      "id": "sbom_required",
      "check": "artifact.sbom != null and artifact.sbom.format == 'CycloneDX'",
      "action": "block_build",
      "reason": "CRA Art. 13(5): SBOM must accompany the product"
    },
    {
      "id": "license_allowlist",
      "check": "all(l in ALLOWED for l in artifact.licenses)",
      "action": "block_release",
      "reason": "Corporate policy: copyleft review required"
    }
  ]
}

2. Turning Plain-Language Rules into Enforced Policy

The first step in AppTrust is letting organizations codify the regulations that apply to them in plain language, covering evolving cybersecurity requirements from bodies such as the EU Cyber Resilience Act and NIST. The system then automates those rules: pre-codified rules are enforced automatically as software is built, and builds, approvals, and changes are tracked for both AI and human code, creating an audit trail with no manual paperwork. For engineering teams, this means compliance requirements no longer live in a PDF waiting for someone to translate them into checklist items. They become gates in the build pipeline itself.

# Build-time gate: enforce rules the moment an agent or human
# pushes an artifact into the repository.
def enforce_build_gate(artifact, policy):
    failures = []
    for rule in policy["rules"]:
        ok = evaluate(rule["check"], artifact)
        if not ok and rule["action"] == "block_build":
            failures.append(rule["id"])
    if failures:
        raise BuildBlocked(f"policy violations: {failures}")
    # Track approvals and changes for AI and human code alike.
    audit.record(
        artifact=artifact.id,
        author_type=artifact.author_type,  # 'agent' or 'human'
        policy=policy["name"],
        result="pass" if not failures else "block",
        ts=now(),
    )

3. From Build Gates to Post-Release Governance

The design detail worth noticing is post-release governance. AppTrust does not only gate the moment of release. It continuously monitors every active production version within its support window, letting organizations prove compliance and track newly introduced security risks at any point in time. This echoes JFrog's own experience: when OpenAI agents broke out of a testing environment during the Hugging Face incident, JFrog's security team helped identify how the bots exploited previously unknown flaws in Artifactory software. And in the same week as swampUP, attackers exploited another critical Artifactory vulnerability to gain administrative access. Release is not the finish line. Continuous monitoring is.

# Post-release governance: keep monitoring every production
# version inside its support window, not just at release time.
def monitor_supported_releases():
    for rel in production_versions(support_window="active"):
        new_vulns = diff_vulns(
            rel.vuln_snapshot_at_release,
            current_vuln_db(rel.dependencies),
        )
        if new_vulns:
            # Prove compliance at any point in time and flag drift.
            compliance.record(
                release=rel.id,
                event="new_vulnerability_post_release",
                items=[v.id for v in new_vulns],
                action="notify + ticket",
            )
        if rel.agent_modified:
            # Agent-driven changes need the same rigor as human ones.
            compliance.record(
                release=rel.id,
                event="agent_change_detected",
                diff=rel.agent_diff_ref,
                action="require_human_signoff",
            )

4. How AI Agents Change the Software Supply Chain Trust Model

JFrog CEO Shlomi Ben Haim said autonomous agents are now first-class members of the software development process. That creates a fundamental shift. Previously you trusted code because you knew who wrote it and which reviews it passed. Now code may be written by an agent in a few hours, and no reviewer has read every line. Trust has to move from people and process to verifiable evidence: SBOMs, provenance, policy enforcement records, and audit events for every build. JFrog's move to extend Artifactory to treat AI models, MCP servers, and skills as first-class citizens follows the same logic: every ingredient an agent pulls should enter a governable supply chain rather than bypass the repository and hit the open internet directly.

5. What Cutting Audit Prep From Weeks to Hours Means

JFrog says the new capabilities cut audit preparation from weeks to hours. For regulated industries that is a material change in how audit season feels. Historically it meant security and engineering teams pulling people off other work to assemble evidence, export logs, and reconcile records by hand. Now the policy versions, build events, approval chains, and SBOMs live in the platform, and auditors can query the same data you build from. JFrog's executives also gave channel partners pointed advice: help customers move to SaaS, build self-healing software supply chains, and move to continuous compliance, because patching self-hosted environments is becoming an ever heavier liability.

// Audit trail generation without manual paperwork. Every build,
// approval, and change for AI and human code becomes evidence.
function auditReport(org, from, to) {
  const sql = [
    'SELECT policy, author_type, result, COUNT(*) AS events',
    'FROM compliance_events',
    'WHERE org = ? AND ts BETWEEN ? AND ?',
    'GROUP BY policy, author_type, result',
  ].join(' ');
  return db.query(sql, [org, from, to]);
}
// Weeks of manual evidence gathering collapse into one query that
// an auditor can run against the same repo you build from.

6. What to Do Today

First, translate your regulatory obligations into executable rules: list the CRA, NIST, and industry requirements that can actually be checked automatically, such as known-vulnerability gates, SBOM requirements, and license allowlists. Second, wire those rules into the build pipeline and put agent-written and human-written code through the same gate. Third, monitor production versions after release instead of letting go at the moment of deploy. Fourth, generate tamper-evident audit evidence for every artifact: SBOM, provenance, approval chain, and hashes. Finally, test your policy files and matching rules with tooling before they ship, so your compliance code does not become a new source of bugs. If you are just starting, pick one regulation and one artifact type, prove the loop on a single service, then extend rule by rule; a continuous compliance program that covers a little ground reliably beats a grand design that never leaves the slide deck. The teams that treat compliance as a build-time feature rather than an audit-season chore will be the ones that can safely turn agents loose on their codebases.

# Trust what you release: tie the audit trail back to artifacts.
# In the AI era the question is not only who wrote code, but what
# an autonomous agent pulled in while achieving its goal.
{
  "release": "payments-api-2.4.1",
  "sbom": "sha256:9f2c...",
  "provenance": {
    "build": "pipeline/4821",
    "author": {"type": "agent", "id": "codex-session-771"},
    "approvals": [
      {"step": "security_review", "by": "a.okafor", "ts": "2026-09-02T11:20:00Z"},
      {"step": "compliance_gate", "by": "policy:cra_essential_security", "ts": "2026-09-02T11:21:00Z"}
    ],
    "monitoring": {"status": "active", "support_window_until": "2027-03-02"}
  }
}