<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Abby Kearns on Medium]]></title>
        <description><![CDATA[Stories by Abby Kearns on Medium]]></description>
        <link>https://medium.com/@ab415?source=rss-5904fd45efbe------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*wyInveUbURnOv_pgXfPJww.jpeg</url>
            <title>Stories by Abby Kearns on Medium</title>
            <link>https://medium.com/@ab415?source=rss-5904fd45efbe------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 18:25:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ab415/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[MCP Inspector Security Advisories: Why AI Agent Developer Tools Belong in Your Dependency Inventory]]></title>
            <link>https://medium.com/governed-at-the-source/mcp-inspector-security-advisories-why-ai-agent-developer-tools-belong-in-your-dependency-inventory-eb69dbcd50b5?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb69dbcd50b5</guid>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 17:00:05 GMT</pubDate>
            <atom:updated>2026-11-04T17:00:05.711Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The tool for checking an MCP server was exposed to the server it was checking.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7jNPhqZzJBm8tajY2cFVLQ.png" /></figure><h3>Key Takeaways</h3><ul><li>On October 21, 2026, the MCP Inspector maintainers published nine security advisories for the Model Context Protocol developer tool, two of them rated Critical at CVSS 9.6.</li><li>Both Critical flaws let a malicious MCP server run commands on the developer’s machine, and both are fixed in 1.0.3 of the deprecated v1 line.</li><li>A High-severity v2 flaw, fixed in 2.12.0, let a remote server run code on Windows and WSL during connection, “with no prompt, no tool call, and no model involvement.”</li><li>These attacks start when the tool does its normal job, connecting to a server nobody has vetted yet.</li><li>AI agent developer tools run with the developer’s credentials, so they belong in the same inventory and patch tracking as production dependencies.</li></ul><p>On October 21, 2026, the maintainers of <a href="https://github.com/modelcontextprotocol/inspector">MCP Inspector</a>, the open source tool developers use to test and debug Model Context Protocol servers, published <a href="https://github.com/modelcontextprotocol/inspector/security/advisories">nine security advisories</a> in one day. Two are rated Critical, and both describe a malicious MCP server running commands on the machine of whoever connected to it. The maintainers <a href="https://github.com/modelcontextprotocol/inspector/releases">shipped fixes the same day</a> and documented each flaw with its affected versions, which is how disclosure should work. Reading through the disclosures, the first thing that came to mind was a simple question: which version are our engineers running right now?</p><h3>What did the MCP Inspector advisories disclose on October 21, 2026?</h3><p>The nine advisories cover both of the tool’s release lines, with two rated Critical, three High, three Moderate and one Low. The two Critical flaws, each scored 9.6 out of 10, affect the older v1 line through version 1.0.2. In <a href="https://github.com/modelcontextprotocol/inspector/security/advisories/GHSA-6x67-4w4w-9f3w">the first</a>, a remote MCP App can steal the token Inspector uses to protect its local proxy, and the advisory sums it up this way: “Connecting to a remote MCP, and just viewing its App makes you completely vulnerable to RCE.” In <a href="https://github.com/modelcontextprotocol/inspector/security/advisories/GHSA-4fc4-wcmh-4g86">the second</a>, a malicious server uses the OAuth sign-in step to switch Inspector from its remote connection to launching a local command of the attacker’s choosing.</p><p>Version 1.0.3 fixes both, and <a href="https://github.com/modelcontextprotocol/inspector/releases">the release notes</a> call it “a security release for the deprecated v1 line.” The newer v2 line needed fixes too, with version 2.12.0 closing three flaws that affect every v2 release from 2.0.0 through 2.11.0. One of them, rated High, lets a remote MCP server run code on Windows and WSL machines, and <a href="https://github.com/modelcontextprotocol/inspector/security/advisories/GHSA-q978-78c7-phqw">its advisory</a> says this “happens during connection, with no prompt, no tool call, and no model involvement.” Another is an <a href="https://github.com/modelcontextprotocol/inspector/security/advisories/GHSA-vcc9-3xgm-p9v4">incomplete fix</a> for <a href="https://github.com/advisories/GHSA-7f8r-222p-6f5g">CVE-2025–49596</a>, a June 2025 flaw that left the connection between Inspector’s interface and its proxy without authentication.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MmafRnPPmj8UdT8S20-cAw.png" /></figure><p>Apart from one flaw that applies only when someone has deliberately switched off authentication, the code-execution paths need the developer to connect to a hostile server first. I don’t find that precondition very reassuring, since connecting to servers is exactly what the tool is for.</p><h3>Why does a developer tool like MCP Inspector need the same governance as a production dependency?</h3><p>In my opinion it needs the same governance because it runs on a developer’s machine with that developer’s access, and in these advisories the attack starts with an ordinary job. Inspector exists so an engineer can point it at an MCP server and see what the server exposes before an agent relies on it, so the servers it connects to are often ones nobody has vetted. The incomplete-fix advisory lists what was within reach: the Inspector’s API token, the OAuth tokens configured for connected servers, which it calls “real downstream credentials,” and the contents of local client configuration files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eMHWK3gSSJfHNGULSlg3gw.png" /></figure><p>The <a href="https://github.com/modelcontextprotocol/inspector">README</a> starts it with npx, so an individual engineer fetches it on demand rather than declaring it in a manifest the build reads, which means a tool like this can stay out of the SBOM, the dependency scanner and the patch schedule without anyone making a deliberate decision.</p><p>Build servers went through the same shift about a decade ago. Teams treated them as plumbing until they realized the machine running builds held credentials for everything it deployed, and that realization moved build servers into the same patching and access reviews as production. MCP tooling is where build servers were before that shift, and because MCP servers don’t yet have anything like the vetting, however thin, that npm and PyPI provide, a developer’s laptop is often the first place an unvetted server connects with real credentials.</p><h3>What should engineering leaders do about MCP Inspector and similar tools now?</h3><p>My advice is to treat them as dependencies with an owner, starting with checks on where they run, how they are patched and which servers they may connect to:</p><ol><li>Find out who on your teams runs MCP Inspector, on which release line and version, and move v1 users to 1.0.3 and v2 users to <a href="https://github.com/modelcontextprotocol/inspector/releases">2.12.0 or later</a>.</li><li>Add AI developer tools, including inspectors, local MCP servers and agent command-line tools, to the inventory and advisory tracking you already run for application dependencies, with a named owner.</li><li>Decide which MCP servers engineers may connect to from a machine that holds production credentials, and give unknown servers a separate environment with no stored tokens.</li></ol><p>None of this should slow engineers down, and I see it as a reasonable response, because if the tool built to make MCP servers safer shipped with these flaws, the rest of the AI tooling on your engineers’ machines deserves the same tracking.</p><h3>What teams running MCP Inspector usually want to know next</h3><p><strong>Has anyone exploited the October 2026 MCP Inspector vulnerabilities?</strong> The two Critical and three High <a href="https://github.com/modelcontextprotocol/inspector/security/advisories">advisories</a> report no exploitation in the wild, and none of them had a CVE identifier as of November 4, 2026.</p><p><strong>Is MCP Inspector v2 affected?</strong> Yes, three flaws, including the Windows and WSL code-execution issue, affect v2 releases 2.0.0 through 2.11.0, and version 2.12.0 fixes them, while the latest release as of November 4 is 2.13.0. The two Critical flaws affect the v1 line from 0.13.0 or 0.20.0, depending on the advisory, through 1.0.2, and 1.0.3 fixes them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jqEbYPCvoz_sNXGBDSEeAg.png" /></figure><p>The maintainers deserve real credit for fixing and documenting nine flaws in a single day. What’s left is a decision for the rest of us about whether the software our engineers use to build agents gets the same inventory and patching as the software those agents end up running.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb69dbcd50b5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/mcp-inspector-security-advisories-why-ai-agent-developer-tools-belong-in-your-dependency-inventory-eb69dbcd50b5">MCP Inspector Security Advisories: Why AI Agent Developer Tools Belong in Your Dependency Inventory</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker Hardened Images and ActiveState (October 2026): Governing Both Layers of the Container]]></title>
            <link>https://medium.com/governed-at-the-source/docker-hardened-images-and-activestate-october-2026-governing-both-layers-of-the-container-757386c49bc7?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/757386c49bc7</guid>
            <category><![CDATA[open-source-software]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 14:03:04 GMT</pubDate>
            <atom:updated>2026-10-29T14:03:04.916Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Securing the whole container, from the hardened base to every package on top.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aFoY36LSytvZekJ2sIFYeA.png" /></figure><h3>Key Takeaways</h3><ul><li>On October 22, we announced a partnership with Docker that pairs Docker Hardened Images with ActiveState’s Curated Catalog, so security teams can secure both the container image and the open source language libraries that run on it.</li><li>Customers can now buy both solutions through a single vendor relationship with either Docker or ActiveState.</li><li>Docker Hardened Images are minimal container images continuously rebuilt from source, and every one, including in the free Community tier, ships with a signed SBOM, SLSA Build Level 3 provenance and OpenVEX data.</li><li>The Curated Catalog gives developers and AI coding assistants a private catalog of approved components across 12 language ecosystems, built from source with SLSA Build Level 3 provenance, so teams have a secure supply of language libraries.</li><li>Together, they give customers a secure foundation for the whole container and continuous remediation as new vulnerabilities appear.</li></ul><p>Docker is the industry standard for containers, and with Docker Hardened Images it has set the bar for what a secure base image should look like, which is why we were so glad to partner with them. On October 22, Docker and ActiveState <a href="https://www.docker.com/blog/docker-activestate-partnership/">announced a joint solution</a> that pairs Docker Hardened Images with ActiveState’s Curated Catalog, and customers can buy both through a single vendor relationship with either company. Docker provides a hardened base with verifiable build provenance, and our catalog extends that same approach to the packages developers and AI coding assistants add on top of it.</p><h3>What makes Docker Hardened Images the right foundation?</h3><p>Docker Hardened Images give teams a minimal, verifiable base for every container, and Docker has made that base available to everyone. <a href="https://www.docker.com/products/hardened-images/">The images</a> are built on Alpine or Debian and continuously rebuilt from source as upstream fixes become available, and Docker reports a 95% smaller attack surface. Every image, including those in the free Community tier, ships with a complete SBOM, SLSA Build Level 3 provenance attestations, a cryptographic signature and OpenVEX exploitability data, and teams can <a href="https://docs.docker.com/dhi/how-to/verify/">verify those attestations</a> with tools such as Docker Scout or cosign. The full catalog is free and open source under the Apache 2.0 license, and the paid tiers add critical CVE fixes under an SLA.</p><p>Making that base free matters for the many teams still working on it. In ActiveState’s recent survey of 250 North American DevSecOps leaders, 90% said their teams still run lightly modified public images with little to no hardening, and 91% named visibility into container components as their biggest blind spot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*izFW1Pp34RmJ3Wxcap2DEw.png" /></figure><h3>How does the Curated Catalog secure the packages on top?</h3><p>The Curated Catalog secures the open source a build installs on top of the base image. In a Dockerfile, a single RUN line such as pip install -r requirements.txt can bring in hundreds of packages, including transitive dependencies, arriving as published wheels, source distributions built during installation or npm packages whose install scripts run during the build. AI coding assistants add to that list quickly, a point Docker made in its announcement, because an assistant can add a package to a manifest while implementing a feature and the next image build installs it.</p><p>ActiveState’s <a href="https://www.activestate.com/partners/docker">Curated Catalog</a> gives those builds a trusted source. It is a private repository of approved components across 12 language ecosystems, built from source in a SLSA Build Level 3 environment with build provenance, and teams <a href="https://docs.activestate.com/curated-catalog/getting-started/">point their repository manager and package managers at it</a> so developers and AI assistants draw from approved components by default. Our components have about 95% fewer CVEs than community open source artifacts, and when a new vulnerability is found, we rebuild the updated packages from source and release them to the catalog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IDPDJey-3zejF_HM7JbgNw.png" /></figure><h3>What does the joint solution give security leaders?</h3><p>Security leaders get the best of both companies, bought through a single vendor relationship. Docker is the industry leader in container images, and ActiveState has spent nearly 30 years building and maintaining open source languages and packages, so each layer of the container is handled by the team that knows it best. Every layer also comes with its own SBOMs and provenance, so security teams can verify what they are running, from the base image through every package installed on top of it.</p><p>For each container in production, three questions are a good place to start:</p><ol><li>Who built the base image, from what source, and with what provenance?</li><li>Where do the application packages come from, including the ones AI coding assistants add?</li><li>Who stands behind each layer when a new vulnerability is disclosed?</li></ol><p>Docker Hardened Images and the Curated Catalog give security teams a clear answer to each of them, for every layer of the container.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=757386c49bc7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/docker-hardened-images-and-activestate-october-2026-governing-both-layers-of-the-container-757386c49bc7">Docker Hardened Images and ActiveState (October 2026): Governing Both Layers of the Container</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI Remediation Bill (October 2026): What Faster Coding Demands of the Business]]></title>
            <link>https://medium.com/governed-at-the-source/the-ai-remediation-bill-october-2026-what-faster-coding-demands-of-the-business-b0d740dda384?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0d740dda384</guid>
            <category><![CDATA[open-source-software]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 16:40:00 GMT</pubDate>
            <atom:updated>2026-10-21T16:40:00.480Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The gains are real. So is the work that grows around them.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ItsBkVHG0JVtUDzgMt2FQ.png" /></figure><h3>Key Takeaways</h3><ul><li>In ActiveState’s study of 307 enterprise technology leaders, 93% report higher engineering productivity and 97% report increased governance workload.</li><li>The report estimates a conservative floor of 139 hours per engineer per year spent revisiting AI-assisted work, and 38% of respondents put it at 11% to 20% of engineering time.</li><li>92% have a formal open source policy, but only 52% say it is consistently followed.</li><li>Despite investments in policies, training, tools and staff, 62% still rely primarily on post-deployment scanning and half say new dependencies can reach production without prior review or approval.</li><li>The fix is a faster approved path for dependencies, with automated checks, continued scanning and a named owner for exceptions.</li></ul><p>When configuration management let infrastructure teams change a thousand servers at once, the bottleneck moved to change approval, testing and rollback, and the teams that owned those steps had to rethink how they worked. AI coding tools are having the same effect on software development. Code gets written faster, and the reviews, security checks and compliance work that follow it have to absorb the extra volume. <a href="https://www.activestate.com/blog/ai-remediation-bill">ActiveState’s AI Remediation Bill study</a> measures how much that work has grown and who is doing it.</p><p>We commissioned this research to find out what AI’s productivity gains ask of everyone downstream of engineering: the security, compliance and operations teams whose work never shows up in an engineering metric. The study surveyed 307 security, governance, platform and engineering leaders at enterprises with at least 1,000 employees in North America and Western Europe in July and August 2026. Beyond the <a href="https://www.activestate.com/press-releases/ai-remediation-bill-study">headline findings</a>, a few results explain why this work is so hard to contain.</p><h3>What work grows alongside AI-assisted development?</h3><p>Governance and remediation work grow with it. 93% of respondents say engineering productivity is up and 91% say they release more often, but 97% say governance workload has increased and 85% say remediation work has too.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aB3d6mGzCX-W5Wvuf_BCPw.png" /></figure><p>The survey doesn’t measure AI’s net time savings, but it does put a number on the rework. Taking the low end of respondents’ estimates, the report puts a conservative floor of 6.7% of engineering time on fixing or revisiting AI-assisted work. That is about 139 hours per engineer over a 2,080-hour working year, and 38% of respondents put the share between 11% and 20%. One platform engineering director said: “Individual teams become more productive, but the overall system doesn’t improve nearly as much because other parts of the organization become bottlenecks.”</p><p>Google’s DORA team reaches a similar conclusion in its <a href="https://services.google.com/fh/files/misc/dora-roi-of-ai-assisted-software-development-2026.pdf">2026 report on the return from AI-assisted development</a>. It describes a “verification tax”: AI tools “increase the sheer volume of code produced, which expands the overall review burden required to meet internal security and architectural standards.” Without strong underlying systems, the report warns, “AI creates localized pockets of productivity that are often lost in downstream chaos.”</p><h3>Why haven’t more policies and tools closed the open source governance gap?</h3><p>Most of those controls still rely on catching problems after the fact, while AI keeps increasing what there is to catch. Organizations have added policies, developer training, governance tools and staff, yet 62% rely primarily on post-deployment scanning, and half say new dependencies can reach production without prior review or approval.</p><p>92% have a formal open source policy, but only 52% say it is consistently followed. That gap doesn’t look like negligence to me. A policy that depends on someone pausing to check struggles once the workflow around it stops pausing, and 96% say AI has increased dependency growth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uUhl6c7Wn3lcfAlTc09N2g.png" /></figure><p>Respondents also worry about what existing controls miss: 68% are more concerned about unknown risks than known ones, and 55% say keeping unapproved open source out is a bigger challenge than seeing what’s already in. As a CIO in manufacturing put it: “It was never tracked proactively, so we don’t know what we don’t know.”</p><h3>What should leaders change first?</h3><p>Start by getting the costs in one place. Only 31% have formally quantified the cost of unmanaged open source risk, and those costs are spread across owners: rework in engineering, release delays in operations, audit findings in compliance and incidents in security. The report doesn’t add them into a single dollar figure because they measure different things, but a CEO can still ask to see them side by side.</p><p>The first lever I’d pull is how dependencies enter development: check each new dependency automatically against security and licensing policy, and send exceptions to a named reviewer. Respondents already lean that way. They put an average of 26% of open source governance effort into prevention before deployment and say it should be 37%.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9q_j3_20UkP3NBEV-4-DCg.png" /></figure><p>Scanning still matters, because a component approved today can have a vulnerability disclosed tomorrow. The split infrastructure teams settled on works here too: routine checks built into the workflow, and people for the decisions that need judgment.</p><p>Moving governance earlier only helps if it doesn’t become a new queue. As a CEO and a technologist, I hold it to two tests: an approved path fast enough that teams choose it by default, and a named owner for the exceptions it can’t handle. That is how faster development stays an advantage for the whole business, not just for the team writing the code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0d740dda384" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/the-ai-remediation-bill-october-2026-what-faster-coding-demands-of-the-business-b0d740dda384">The AI Remediation Bill (October 2026): What Faster Coding Demands of the Business</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The SAFE Proposal (2026): What AI Incident Notification Should Include]]></title>
            <link>https://medium.com/governed-at-the-source/the-safe-proposal-2026-what-ai-incident-notification-should-include-53f9f397d4fa?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/53f9f397d4fa</guid>
            <category><![CDATA[open-source-software]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Fri, 16 Oct 2026 17:55:15 GMT</pubDate>
            <atom:updated>2026-10-16T17:55:15.529Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L6o4CrLMPdfSz1KReDf0ww.png" /></figure><p><em>Investigating an agent incident requires evidence your vendor may hold.</em></p><h3>Key Takeaways</h3><ul><li>The Shared AI Findings Exchange (SAFE) is a draft proposal published in August by the Open Secure AI Alliance, which moved under Linux Foundation governance on September 14. Contributions to the draft were invited through September 21.</li><li>SAFE proposes prompt notice to directly affected organizations, a 72-hour customer notification window for credible exposure, and a preliminary public report at 30 days, subject to security, legal and investigative constraints.</li><li>Its evidence requirements cover the records needed to reconstruct an agent’s activity, including instructions, tool use, identities, permissions and human interventions.</li><li>Reporting would be a condition of membership. The proposal is not an executed agreement and does not replace existing contractual and legal obligations.</li><li>Security leaders can use it to discuss evidence access with vendors, including retention, delivery and secure handling, before an incident makes those questions urgent.</li></ul><p>A vendor can tell you that its agent caused an incident without giving your team enough information to investigate it. The<a href="https://github.com/OpenSecureAIAlliance/RFCs/blob/main/rfc-safe-proposal.md"> Shared AI Findings Exchange</a>, or SAFE, proposes that members provide both notice and the evidence an affected organization needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_7Q9raPDtCYFrIzCKXXr8A.png" /></figure><p>SAFE was<a href="https://www.linuxfoundation.org/blog/proposing-the-safe-working-group-an-open-community-effort-to-improve-ai-security"> first published in August</a>. The Open Secure AI Alliance<a href="https://www.linuxfoundation.org/blog/open-secure-ai-alliance-joins-the-linux-foundation-to-build-a-shared-open-defense-stack-for-the-ai-era"> moved into the Linux Foundation on September 14</a>, and that announcement invited contributions through September 21. The draft contains a reporting compact: a list of what a member would have to tell you when one of its agents goes somewhere it should not.</p><h3>What Would SAFE Require After an AI Incident?</h3><p>Under SAFE’s proposed compact, members would notify affected organizations and share evidence when they become aware of, or reasonably suspect, a reportable incident involving an AI system they operate.</p><p>The triggers cover unauthorized activity against third-party systems, boundary escapes that affect others, access to confidential information without consent, and continued activity against a production target after the operator suspects it is unauthorized or out of scope. An authorized agent doing its assigned work would not trigger reporting simply because it accessed another organization’s systems.</p><p>The notification and reporting schedule is:</p><ul><li><strong>ASAP:</strong> Notify the directly affected organization.</li><li><strong>72 hours:</strong> Notify customers with credible exposure.</li><li><strong>4 business days:</strong> Submit an initial confidential report to SAFE.</li><li><strong>14 days:</strong> Issue a broader customer advisory when warranted.</li><li><strong>30 days:</strong> Publish a preliminary factual report, subject to security, legal and investigative constraints.</li><li><strong>90 days:</strong> Publish remediation status.</li><li><strong>Weekly:</strong> Provide machine-readable updates while material risks remain unresolved.</li></ul><p>The proposal does not explicitly define when each clock starts. A vendor agreement would need to specify that.</p><p>The draft also makes intent irrelevant to whether an incident is reportable. Believing an environment was simulated would not remove the reporting duty. In its<a href="https://openai.com/index/hugging-face-incident-and-the-road-ahead/"> August 26 account</a>, OpenAI describes agents escaping an evaluation environment and compromising Hugging Face. Hugging Face publicly disclosed the activity on July 16; OpenAI says it connected the activity to its evaluations on July 20 and notified Hugging Face.</p><h3>What Evidence Would an Affected Organization Need?</h3><p><a href="https://www.activestate.com/blog/when-the-board-asks-what-happened-will-you-have-an-answer?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=sep14_ceo">An investigation needs the records of what the agent was instructed to do, what it could access and what it actually did.</a> Your own logs may capture only part of that.</p><p>SAFE’s evidence list includes prompts, traces, tool calls, configurations, model and safeguard versions, identities, permissions, credentials available during the run, and human approval or intervention events. It also calls for records of modified files, detection and recovery, reproduction testing and remediation. Members would also have to provide a preliminary control-failure analysis within 30 days.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HxEj6hLWlPSB6MstGUSWXw.png" /></figure><p>Your team might see an agent changing a file or accessing a service without being able to see the instructions or tool responses that preceded it. If those records sit inside the vendor’s platform, your investigation depends on what the vendor retained and will share.</p><p>Incident responders already work with automation and incomplete records. I see the additional difficulty here in reconstructing an agent’s run across instructions, tool calls and responses, especially when repeating it may produce a different sequence. Knowing when the vendor will notify you still leaves the question of which records your team can examine.</p><h3>How Can Security Teams Use SAFE Before it is Adopted?</h3><p>Security teams can compare the proposal with their vendor agreements to identify what they have already secured and what they still need to negotiate.</p><p>The compact would make reporting a membership commitment, while keeping confidential learning separate from enforcement and preserving existing obligations. Joining the Alliance is not, by itself, evidence that a vendor has agreed to give your team access to the records listed here.</p><p>Sharing findings could help other operators recognize and prevent similar failures. An affected customer also needs access to records while its own investigation is underway.</p><p>Ask a vendor to walk through an incident with you: <a href="https://www.activestate.com/blog/building-reproducible-software-environments-a-practical-guide?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=sep14_ceo">when notification would begin, which records it retains, how long it keeps them, who can request them and how quickly it can deliver them. </a>Put those answers in the agreement so your response team knows what to expect.</p><p>Prompts and traces can contain confidential information. Investigators need to know which credentials were available without circulating live secrets. Security and legal teams would need to agree on how to transfer the records securely, who can access them and what can be redacted without losing the facts needed to investigate.</p><p>SAFE is specific about the records an affected organization should receive. I’d want the same specificity about when my team could get them. During an incident, we may need those records to decide what to contain or shut down, well before anyone is ready to publish a report.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53f9f397d4fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/the-safe-proposal-2026-what-ai-incident-notification-should-include-53f9f397d4fa">The SAFE Proposal (2026): What AI Incident Notification Should Include</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[npm Stage-Only Tokens (September 2026): Choosing Who Can Release Your Code]]></title>
            <link>https://medium.com/governed-at-the-source/npm-stage-only-tokens-september-2026-choosing-who-can-release-your-code-f6bdd2db3e21?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6bdd2db3e21</guid>
            <category><![CDATA[software-security]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[open-source-software]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 18:41:41 GMT</pubDate>
            <atom:updated>2026-09-24T18:41:41.882Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mVTaTiwCziyXwsS4dtc8PQ.png" /></figure><p><em>npm is targeting January 2027 to end direct publishing through bypass-2FA tokens. Teams still have to decide how much authority their workflows should have.</em></p><h3>Key Takeaways</h3><ul><li>npm’s new <a href="https://github.blog/changelog/2026-09-18-stage-only-npm-tokens-for-safer-automation/">stage-only access tokens</a> let a workflow submit a version for maintainer approval with two-factor authentication. The release is opt-in and leaves existing tokens unchanged.</li><li>npm is targeting January 2027 to remove direct publishing through bypass-2FA tokens. Stage-only tokens still retain other write permissions, including changing dist-tags and deprecating versions.</li><li><a href="https://github.blog/changelog/2026-09-03-multiple-trusted-publishing-configurations-for-npm/">Trusted publishing still permits direct releases</a> when explicitly enabled per configuration. Human approval is required for staged releases, not every automated release.</li><li>Migrating to staged publishing means using npm stage publish, npm CLI 11.15.0 or later, and Node.js 22.14.0 or later.</li><li>Teams choosing staged publishing need a reviewer who can investigate unexpected changes and delay the release when necessary.</li></ul><p>An npm workflow can now prepare a release without having permission to publish it. On September 18, the registry introduced a granular access token that submits a version for a maintainer to review and approve with two-factor authentication. Direct npm publish attempts using that token are rejected, even if 2FA bypass is configured.</p><p>That gives engineering teams a choice about how much authority to leave in their release pipelines. Trusted publishing still allows fully automated releases when explicitly enabled. Teams choosing staged publishing put a person between the workflow and publication, which creates an operational responsibility: someone has to understand the proposed release well enough to approve it.</p><h3>What Changed in npm Publishing, and What is the January Target?</h3><p>Stage-only tokens are available now, and npm is targeting January 2027 to remove direct publishing through bypass-2FA tokens. The September release does not change existing tokens or their ability to publish directly.</p><p>Two September announcements describe the options:</p><ol><li><a href="https://github.blog/changelog/2026-09-03-multiple-trusted-publishing-configurations-for-npm/"><strong>September 3: trusted-publishing configurations.</strong></a> npm added support for multiple configurations per package. Each can stage by default, while direct publishing is opt-in per configuration. npm recommends staging, and approval remains disabled until malware scanning finishes.</li><li><a href="https://github.blog/changelog/2026-09-18-stage-only-npm-tokens-for-safer-automation/"><strong>September 18: stage-only tokens.</strong></a> Teams using token-based automation gained a credential that can submit versions for approval without permission to publish new versions directly.</li></ol><p>Stage-only tokens retain permissions to move dist-tags and deprecate versions, so they still need protection. And a completed malware scan does not establish that a release is safe; it allows the maintainer to proceed with approval.</p><p>This continues the changes GitHub <a href="https://github.blog/security/supply-chain-security/our-plan-for-a-more-secure-npm-supply-chain/">announced in September 2025</a> after the Shai-Hulud worm compromised maintainer accounts. That plan called for stronger authentication, shorter-lived granular tokens and wider adoption of trusted publishing. A year later, npm is giving teams another way to separate automated preparation from permission to release.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dkT9240pmskIE2QyLJAgrw.png" /></figure><h3>What Makes a Release Approval Useful?</h3><p>A reviewer needs enough context to assess the release, time to investigate unexpected changes and authority to stop publication. How often that person is interrupted matters, and so does what they are being asked to assess.</p><p>Anthropic’s <a href="https://claude.com/blog/auto-mode-default-in-claude-code">research on permission prompts in Claude Code</a> shows why frequency deserves attention. Users approved 97% of prompts, although Anthropic notes that most likely concerned safe, routine commands. In its commissioned experiment, 1,053 paid testers worked in a test environment where one prompt was replaced with a dangerous command. They caught 13.6% of those commands; auto mode blocked 89%. Human detection fell from about 17% early in a session to about 5% after 50 or more prompts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a4jbwnBf-n5N_CYW1B0LhA.png" /></figure><p>Those results support concern about repeated interruptions. They do not establish that an infrequent release approval will catch malicious code. Publishing schedules vary, and a person approving releases across dozens of packages can face a substantial queue.</p><p>Staging does give the team an opportunity to inspect a release before downstream users can install it. The reviewer should be able to connect the package to the intended source revision and build, understand unexpected changes and see what testing was completed. Once a harmful version has been installed, removing it from the registry cannot undo what it ran on someone else’s system.</p><h3>How Should Engineering Teams Prepare for npm’s January Target?</h3><p>Start with the workflows that use bypass-2FA tokens to publish directly, then choose and test their replacement. Teams already using trusted publishing should inspect which configurations permit direct publication.</p><ol><li><strong>Review trusted-publisher permissions.</strong> OpenID Connect (OIDC) authenticates the CI workflow using its identity, removing the need for a stored publishing token. Check the repository, workflow and environment criteria for each configuration, alongside its permission to publish directly. npm evaluates configurations independently; a restrictive configuration does not cancel a more permissive one.</li><li><strong>Test the staged-publishing path.</strong> For token-based automation, create a stage-only token and change npm publish to npm stage publish. Check runner images for npm CLI 11.15.0 or later and Node.js 22.14.0 or later. Staged publishing works with existing packages and requires publish access and an account with 2FA enabled.</li><li><strong>Assign release coverage.</strong> Where approval is required, establish who reviews routine releases and urgent fixes, what information they receive and who covers their absence. Test the handoff before relying on it during an incident.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tCl_vokOOR2DLOzlwG3dOQ.png" /></figure><p>For a pipeline my team owns, I would want to know which workflows can publish directly and why, and whether the person approving the rest could realistically say no.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6bdd2db3e21" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/npm-stage-only-tokens-september-2026-choosing-who-can-release-your-code-f6bdd2db3e21">npm Stage-Only Tokens (September 2026): Choosing Who Can Release Your Code</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Work Between a Patch and Production]]></title>
            <link>https://medium.com/governed-at-the-source/the-work-between-a-patch-and-production-16133c372ab8?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/16133c372ab8</guid>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 15:29:24 GMT</pubDate>
            <atom:updated>2026-09-10T15:29:24.947Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*od3A7gMYVjmCxikp5a61eg.png" /></figure><p><em>A fix can be available for days before it reaches the systems that need it.</em></p><h3>Key Takeaways</h3><ul><li>JFrog released fixes for CVE-2026–82329 on August 28, and watchTowr reported attackers exploiting it to mint administrative tokens by September 1. That is four calendar days between patch and reported attacks, and it does not establish when exploitation actually began.</li><li>Verizon’s 2026 DBIR puts the median time to fully remediate a known-exploited vulnerability at 43 days, up from 32 the year before.</li><li>A Qualys-contributed analysis in the same report, covering more than a billion remediation records across four reporting cycles, found 60% to 70% of known-exploited vulnerability instances still open in the first week after detection.</li><li>Those figures measure remediation after detection, while the Artifactory dates measure patch availability to reported exploitation. They describe different populations, so subtracting one from the other says little about any single company’s exposure.</li><li>Preparation moves the number. Spotify deployed a Log4j fix to 80% of its production backend services within nine hours of merging its initial fix, on the back of automated testing, deployment checks, and regular redeployment.</li></ul><p>If you run Artifactory, the end of August was an uncomfortable few days. JFrog shipped a fix for an authentication bypass on the 28th, <a href="https://docs.jfrog.com/releases/docs/artifactory-self-managed-releases">documented in its release notes</a>. By September 1, <a href="https://www.linkedin.com/posts/activity-7500409591113891840--jml">watchTowr was reporting</a> attackers using that same flaw to mint themselves administrative tokens. The patch existed the whole time. Whether it had reached your systems is a different question, and it is the more useful one.</p><p>Four calendar days is all those dates give us. They do not tell us when exploitation actually began, or how many customers had already upgraded. I would want to know how our own process would have handled that week. An artifact repository sits under the build and release pipelines for a whole organization, so upgrading it takes testing and coordination, for good reason. The question is whether we know how long that takes, and what stays exposed while it does.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sxWW_cE5euG_0K32XIXntg.png" /></figure><h3>What the Remediation Numbers Tell Us</h3><p>Verizon’s <a href="https://www.verizon.com/business/resources/T1e0/reports/2026-dbir-data-breach-investigations-report.pdf">2026 Data Breach Investigations Report</a> puts the median time to fully remediate known-exploited vulnerabilities within an organization at 43 days, up from 32. Full remediation in their terms means every detected instance of it, not the first one somebody fixed.</p><p>A separate analysis in the report, contributed by Qualys and drawing on more than a billion anonymized remediation records across four consecutive reporting cycles, found that 60% to 70% of known-exploited vulnerability instances remained open in the first week after detection. Verizon says that first-week rate has barely moved, despite more process, more tooling, and more regulatory pressure.</p><p>These figures measure remediation after detection, while the Artifactory example measures patch availability to reported exploitation. Different populations, different starting points, so subtracting one from the other tells us very little about an individual company. They are still a reason to look hard at that interval. Verizon points to growing vulnerability volume and constraints at current resource levels, but its findings do not tell us that tooling is irrelevant, that faster remediation is impossible, or which part of a given company’s process needs attention.</p><h3>Follow the Fix Through the Organization</h3><p>A vendor advisory can arrive before a team knows which systems are affected. Once that is established, someone needs to own the upgrade, test it, approve it, deploy it, and verify the affected instances. The delay could be an unclear handoff, or a compatibility problem that takes real engineering work to resolve.</p><p>Those need different responses. <a href="https://www.activestate.com/blog/ai-coding-security-risks?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=sep7_ceo">An unassigned ticket needs an owner.</a> A difficult upgrade may need better tests, a rollback plan, or a supported migration path. Treating both as a generic patching backlog hides what would actually help.</p><p>Some waiting is deliberate. Dependabot’s <a href="https://github.blog/changelog/2026-07-14-dependabot-version-updates-introduce-default-package-cooldown/">version-update cooldown</a> and Renovate’s <a href="https://docs.renovatebot.com/key-concepts/minimum-release-age/">minimum release age</a> give researchers time to catch malicious releases, and both exempt recognized security updates, though detection and deployment still take time. Neither necessarily governs an Artifactory service upgrade. Look at the process that actually delivers the fix to the affected system.</p><p>Preparation changes this, sometimes dramatically. In a <a href="https://engineering.atspotify.com/2023/4/spotifys-shift-to-a-fleet-first-mindset-part-1">2023 account of its fleet management program</a>, Spotify reported deploying a Log4j fix to 80% of its production backend services within nine hours of merging its initial fix, with services outside that managed fleet taking a few more days. The company had invested in automated testing, deployment checks, and regular rebuilding and redeployment. That was a library rollout rather than a shared-service upgrade like Artifactory, but it shows how an established deployment path gets a fix to production quickly.</p><p>Some preparation is more basic. A critical service can already have a named upgrade owner, a tested rollback procedure, and an agreed route for emergency approval. The team still needs to assess the particular fix. It should not also have to negotiate who can authorize the work while the system is exposed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N76kjUd_6bKgekR4l7P_RQ.png" /></figure><h3>Measure A Few Real Cases</h3><p>I would start with the last five critical vulnerabilities in infrastructure your builds depend on. For each, record when the vendor made a fix available, when the team identified the affected systems, and when remediation was verified. If disclosure preceded the fix, record that separately.</p><p>Be specific about that last date. <a href="https://www.activestate.com/blog/ai-accelerated-development-it-also-accelerated-your-remediation-backlog?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=sep7_ceo">A merged pull request or a rebuilt image records progress, but an older version may still be running, so close the measurement only when the affected instances have been checked.</a> Record temporary mitigations separately so they stay visible until the permanent fix lands.</p><p>Then look between those dates. How long did identification take? Where did the change wait? How much went into testing or resolving a compatibility issue? A sample this small will not establish a benchmark, but it shows where a closer look would help.</p><p>Some of that time cannot safely be removed, which raises a second question: what reduces exposure while the upgrade is pending? <a href="https://www.activestate.com/blog/the-worlds-most-critical-systems-cant-just-upgrade-to-the-latest-version?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=sep7_ceo">Depending on the vendor’s guidance, that might mean restricting access, disabling a feature, or isolating the service.</a> Any such measure needs an owner and a check that it addresses the relevant attack path.</p><p>That is the discussion I would want after an incident like this. Faster deployment may be achievable in places and some delays may be justified, and leadership should be able to tell the two apart and understand the exposure it is accepting in the meantime.</p><p>A patch gives you something to act on. Knowing when it actually reaches the systems that need it, and how those systems are covered until then, is part of owning the infrastructure.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16133c372ab8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/the-work-between-a-patch-and-production-16133c372ab8">The Work Between a Patch and Production</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NIST’s NVD Enrichment Cutback (September 2026): Why Comprehensive Coverage Claims Now Need a Source…]]></title>
            <link>https://medium.com/governed-at-the-source/nists-nvd-enrichment-cutback-september-2026-why-comprehensive-coverage-claims-now-need-a-source-0eb4defca408?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/0eb4defca408</guid>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Thu, 03 Sep 2026 15:46:23 GMT</pubDate>
            <atom:updated>2026-09-03T15:46:23.664Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QyKgf6Xxr7FMWo7ZUhixpg.png" /></figure><h3>NIST’s NVD Enrichment Cutback (September 2026): Why Comprehensive Coverage Claims Now Need a Source List</h3><p><em>FIRST’s data says exploitable risk stayed flat. That supports NIST’s prioritization and complicates your coverage claim.</em></p><h3><strong>Key Takeaways</strong></h3><ul><li>On April 15, 2026, NIST stopped attempting universal enrichment of the National Vulnerability Database, prioritizing CISA KEV entries, federal government software, and software critical under Executive Order 14028. The rest are marked “Lowest Priority — not scheduled for immediate enrichment.”</li><li><a href="https://www.first.org/newsroom/releases/20260615">FIRST raised its 2026 forecast to roughly 66,000 CVEs in June but found actionable exploitability flat once filtered for KEV or EPSS above 10%.</a> NIST put KEV, one of those two signals, at the top of its list, which makes the allocation understandable rather than sufficient: product mapping helps establish whether a CVE touches your estate, while KEV and EPSS prioritize what is already in view.</li><li>The exposure falls on programs that claim comprehensive coverage, rely materially on NVD-added product mappings, and cannot say what else feeds their tooling.</li><li>NVD’s CPE coverage was already partial, measured by VulnCheck at 41.35% of 2024 CVEs. Whether your tools supplement it is a fact about your vendor rather than something the dashboard reports.</li></ul><p><a href="https://www.nist.gov/news-events/news/2026/04/nist-updates-nvd-operations-address-record-cve-growth">In April, NIST announced the National Vulnerability Database would stop trying to enrich everything it receives.</a> Enrichment is the analyst work that makes a CVE record actionable: CPE strings naming affected products and versions, a severity score, a weakness classification. NIST was responding to a capacity problem. CVE submissions grew 263% between 2020 and 2025, and even after nearly 42,000 enrichments in 2025, a record, the NVD could not keep pace.</p><p>In June, FIRST raised its 2026 projection from a February median of 59,427 to roughly 66,000, with actuals already 46.3% above forecast by April. FIRST attributes the surge to increased discovery and reporting capacity rather than declining software quality, with AI-assisted vulnerability discovery among the drivers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H02IfUscFqsPxDFNOvpumQ.png" /></figure><p>It would be easy to read those two announcements together and conclude that discovery is accelerating while the infrastructure that makes those discoveries useful is pulling back. That is where I started, before the data sent me in a different direction.</p><h3><strong>Did the Risk Actually Get Worse?</strong></h3><p><a href="https://www.first.org/epss/">FIRST used KEV and EPSS above 10% as its measure of actionable risk.</a> On that basis, exploitability remained flat and the patching burden “has not materially increased, despite the surge in raw volume.” Its advice to security teams was simple: “the playbook hasn’t changed.”</p><p><a href="https://www.cisa.gov/known-exploited-vulnerabilities-catalog">NIST also put KEV first.</a> It does not use EPSS, and its other priorities reflect the federal government’s own scope, so the two approaches are not identical. Even so, the overlap makes NIST’s decision understandable. It does not answer the coverage question. KEV and EPSS help teams prioritize vulnerabilities; product mappings help establish whether those vulnerabilities touch the estate at all. Better prioritization cannot recover something that never entered the queue.</p><h3><strong>Whose Coverage Claim Changed?</strong></h3><p>The effect depends on what sits behind the dashboard, a distinction much of the early commentary missed, including my first draft of this piece.</p><p>CPE helps a scanner answer the first question a security team needs resolved: does this vulnerability affect something we run? If your tooling matches on NVD-added CPE strings and nothing else, it can no longer assume NIST will add that mapping for CVEs outside the prioritized categories, and a finding that should have surfaced can go missing instead.</p><p>Whether that happens depends on how your vendor built the product and which sources it uses alongside NVD: CNA-supplied data, GitHub Security Advisories, OSV, VulnCheck, or its own research. <a href="https://www.vulncheck.com/blog/outpacing-nvd-cp">VulnCheck, describing its own layer in late 2024, measured NVD as supplying CPE for 41.35% of that year’s CVEs against 76.95% for its own. </a>That is vendor analysis, but it shows incomplete NVD coverage predating April.</p><p>NIST is not the only source of metadata. The originating CNA may already have supplied affected-product data, a CVSS score, and a weakness classification. What may be absent is NIST’s added CPE mapping or independent severity assessment.</p><p>The word comprehensive is doing a lot of work here. We put it in reports for boards, auditors, and underwriters as though its meaning is obvious, but it often rests on a chain of enrichment sources the report never names. NIST’s change brings that dependency into view. The coverage may be sound, but the report should be able to show where it comes from.</p><h3><strong>What Should a Security Leader Check This Quarter?</strong></h3><p>There are three questions I would ask this quarter.</p><p>Ask your vendor which sources feed its matching and scoring, not only whether they use the NVD but what sits alongside it. If the answer is vague or takes a week, that difficulty is part of what you are measuring.</p><p>Ask what happens to a CVE your tooling cannot map to an asset, because whether it surfaces as a low-confidence finding, gets suppressed, <a href="https://www.activestate.com/blog/cyber-resilience-open-source-governance?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug31_ceo">or never enters the queue decides whether an unenriched record is visible to you at all.</a></p><p>Then ask what your own reporting asserts. If it uses the word comprehensive, it should name what that rests on, and if it cannot, <a href="https://www.activestate.com/blog/beyond-the-scanner-how-to-build-an-open-source-security-toolchain-that-keeps-pace-with-ai?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug31_ceo">the honest fix is to change the sentence rather than the scanner.</a></p><p>I would be skeptical of any vendor, mine included, that treats this as a purchasing occasion. NIST made a defensible call under real constraints, and the one thing it cannot do is keep your claim true on your behalf.</p><h3><strong>The Questions People Will Reasonably Ask</strong></h3><h4><strong>Are the unenriched CVEs gone from the NVD?</strong></h4><p>No. All submitted CVEs are still added, and the “not scheduled for immediate enrichment” label describes scheduling rather than permanent exclusion.</p><h4><strong>If exploitable risk is flat, does any of this matter?</strong></h4><p>It matters for any program whose stated coverage is broader than KEV- and EPSS-based triage. FIRST’s finding supports a risk-prioritized program without substantiating a claim of comprehensive coverage.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0eb4defca408" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/nists-nvd-enrichment-cutback-september-2026-why-comprehensive-coverage-claims-now-need-a-source-0eb4defca408">NIST’s NVD Enrichment Cutback (September 2026): Why Comprehensive Coverage Claims Now Need a Source…</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Snowflake GitHub Actions Flaw (Disclosed August 2026): How an Ordinary Refactor Removed a…]]></title>
            <link>https://medium.com/governed-at-the-source/the-snowflake-github-actions-flaw-disclosed-august-2026-how-an-ordinary-refactor-removed-a-d9b6eb556d9e?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9b6eb556d9e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 19:18:27 GMT</pubDate>
            <atom:updated>2026-08-26T19:18:27.292Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-sJg5pQAlhK5WGCgaxT1Dg.png" /></figure><h3>The Snowflake GitHub Actions Flaw (Disclosed August 2026): How an Ordinary Refactor Removed a Security Boundary</h3><p><em>The safe pattern already existed. Nothing stopped the change that removed it.</em></p><h3><strong>The Short Version</strong></h3><ul><li>An ordinary refactor in Snowflake’s public `snowflake-connector-net` repository replaced a safe GitHub Actions input-handling pattern with direct interpolation of an attacker-controlled issue title into a shell command.</li><li>The change silently removed an existing security property. Human review and GitHub Advanced Security did not stop the regression, and Wiz says Copilot checked the merged change and identified it as all-clear. GitHub rejects that characterization.</li><li>Snowflake patched the workflow on June 23, the same day Wiz reported it, and said its investigation found no evidence of unauthorized access.</li><li>Wiz’s autonomous Red Agent found and exploited the flaw five days after it became live, showing how quickly automated discovery can reach a regression after deployment.</li><li>Copilot did not demonstrably write the vulnerable code. The durable engineering response is to enforce safe handling of untrusted input at the workflow boundary, regardless of who authored the change.</li></ul><p>Snowflake already had the safer version of this code. Its GitHub Actions workflow took the title of a public issue, kept it in an environment variable, and passed it safely to <em>jq</em>. Then a routine refactor put that same title directly inside a shell command, where the shell could interpret the data as code.</p><p>The <a href="https://github.com/snowflakedb/snowflake-connector-net/commit/4a1b8ce">merge commit</a> passed human approval, and GitHub Advanced Security did not flag the injection. Five days after it went live, Wiz’s autonomous Red Agent found the flaw and worked out how to exploit it. The team knew how to handle this input safely. What was missing was a rule that made the safe handling survive the refactor.</p><h3><strong>What Happened in Snowflake’s GitHub Actions Workflow?</strong></h3><p>The flaw allowed anyone with a GitHub account to inject commands into the workflow runner through a carefully written issue title. The workflow placed <em>${{ github.event.issue.title }}</em> directly inside a shell command, so a single quote in the title could break out of the string and run something else. <a href="https://docs.github.com/en/actions/concepts/security/script-injections">GitHub’s own documentation]</a> names <em>github.event.issue.title</em> as untrusted input and warns against this exact pattern.</p><p>The unsafe pattern entered the pull request in August 2025 and reached the default branch when <a href="https://github.com/snowflakedb/snowflake-connector-net/pull/1218">PR #1218</a> was merged on June 18, 2026. <a href="https://www.wiz.io/blog/red-agent-snowflake-copilot-cicd-bug)">Wiz reported the vulnerability</a> through Snowflake’s HackerOne program on June 23. Snowflake <a href="https://github.com/snowflakedb/snowflake-connector-net/pull/1402">patched it that day</a>, restored the environment-variable and <em>jq — arg</em> pattern, and rotated the Jira credential on June 24. Snowflake said its investigation found no evidence of unauthorized access.</p><p>Snowflake’s response was quick, and the incident appears to have been contained. However, the problem came earlier: a known-safe pattern disappeared during a refactor, a person approved the change, and GitHub Advanced Security did not catch it. Wiz says Copilot missed it too, though GitHub disputes that account.</p><h3><strong>Why Did the Existing Review Controls Miss the Regression?</strong></h3><p>The reviews looked at the change, but none enforced the rule that mattered most: values supplied through public GitHub events should never be inserted directly into a shell command. The final revision passed because the safe handling lived in the old code rather than in a policy the new code had to satisfy.</p><p>The difference is easy to miss in review. Both versions take an issue title and create a Jira ticket. What changed is where the title becomes visible to the shell, and that detail carries the security of the whole workflow. A green check tells you a tool ran. It does not tell you the tool understood that particular boundary.</p><p>Copilot became part of the story because Copilot Autofix contributed a separate change to <em>jira_close.yml</em> in the same pull request. Wiz later clarified its position: “Copilot was a co-author that checked the merged PR and code change, and identified it as all-clear without noticing the critical vulnerabilities.” Wiz also says it remains unclear whether AI helped write the vulnerable change itself.</p><p><a href="https://thenextweb.com/news/snowflake-copilot-autofix-wiz-red-agent-github-dispute">GitHub disputes that account</a>. In statements to reporters, GitHub said its internal review found a human wrote the contributions that led to the vulnerability and that Copilot Autofix neither reviewed nor contributed to them. GitHub has not published the review or the underlying telemetry, so the disagreement remains unresolved.</p><p>The disagreement is worth reporting, but it does not change the engineering question. A person or a tool could make the same mistake. <a href="https://www.activestate.com/blog/beyond-the-scanner-how-to-build-an-open-source-security-toolchain-that-keeps-pace-with-ai?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug24_ceo">The release process still needs to reject the unsafe result.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_h-k_SCoQI5_r4v8RZRLCA.png" /></figure><h3><strong>What Should Engineering Teams Enforce in Privileged Workflows?</strong></h3><p>Engineering teams should write down the rule in plain language that is clear: public GitHub input is untrusted, and it never goes directly into a shell command. Then the pipeline needs to check the rule every time the workflow changes.</p><p>That might mean linting GitHub Actions files, blocking <em>${{ github.* }}</em> expressions inside <em>run:</em> blocks, testing workflows with hostile event data, or requiring public values to cross an environment-variable boundary before the shell sees them. Whichever mechanism a team chooses, the rule needs to live outside the particular implementation a developer happens to be editing.</p><p>Wiz’s Red Agent found and exploited this vulnerability five days after it became live. That is a very short interval between an ordinary regression reaching production and an automated system learning how to use it. Review and broad scanning still matter, but they are too general to carry this boundary by themselves.</p><p>Snowflake already had the safe code. What it needed was a control that understood why the code was safe. <a href="https://www.activestate.com/blog/when-an-ai-tool-introduces-a-vulnerable-package-whos-responsible?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug24_ceo">As software changes faster, that difference matters more than who typed the vulnerable line.</a></p><h3><strong>The Questions People Will Reasonably Ask</strong></h3><h4><strong>Was Snowflake breached through this vulnerability?</strong></h4><p>Snowflake said its investigation found no evidence of unauthorized access. <a href="https://www.wiz.io/blog/red-agent-snowflake-copilot-cicd-bug">Wiz said</a> comprehensive audit log analysis identified its testing as the only activity during the five-day exposure window and that it deleted the data accessed during the proof of concept.</p><h4><strong>Was the GitHub Actions vulnerability patched?</strong></h4><p>Yes. Snowflake restored the environment-variable and <em>jq — arg</em> handling pattern on June 23, 2026, the same day Wiz reported the issue, and rotated the Jira credential on June 24.</p><h4><strong>Did GitHub Copilot create the vulnerable code?</strong></h4><p>That has not been established. Wiz says it is unclear whether the vulnerable change was AI-assisted. GitHub says its internal review found a human wrote the contributions that led to the vulnerability, but it has not published that review. The documented Copilot Autofix contribution applied to a different workflow file.</p><p>Wiz separately says Copilot checked and cleared the merged change. GitHub disputes that review claim. Neither account establishes authorship.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9b6eb556d9e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/the-snowflake-github-actions-flaw-disclosed-august-2026-how-an-ordinary-refactor-removed-a-d9b6eb556d9e">The Snowflake GitHub Actions Flaw (Disclosed August 2026): How an Ordinary Refactor Removed a…</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code’s Auto Mode Default (August 2026): Why the Human Approval Gate Stopped Being a Security…]]></title>
            <link>https://medium.com/governed-at-the-source/claude-codes-auto-mode-default-august-2026-why-the-human-approval-gate-stopped-being-a-security-4b5b6a139b53?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b5b6a139b53</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-supply-chain]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 17:54:54 GMT</pubDate>
            <atom:updated>2026-08-19T17:54:54.100Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EL_B9j87und4Ve0SlMk_wA.png" /></figure><h3>Claude Code’s Auto Mode Default (August 2026): Why the Human Approval Gate Stopped Being a Security Control</h3><p>Anthropic’s own research says the prompt caught one dangerous command in seven. Its own changelog says the prompt was not always showing you the whole command.</p><p><strong>Key Takeaways</strong></p><ul><li>On <strong>August 14, 2026</strong>, <a href="https://claude.com/blog/auto-mode-default-in-claude-code">Anthropic made auto mode the default</a> in Claude Code for Pro, Max, and Team plans. A classifier now decides which tool calls need your approval.</li><li>Claude Enterprise, the Claude API, Claude Platform on AWS, Amazon Bedrock, Google Cloud’s Agent Platform, and Microsoft Foundry are exempt “for now.” Anthropic says it plans to change that across all of them within about a month.</li><li>Anthropic’s own numbers carry the argument. Users approve 97% of permission prompts. Given a planted dangerous command, 1,053 paid testers caught it 13.6% of the time. The classifier caught 89%.</li><li><a href="https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md">Claude Code’s changelog</a> records at least eight fixes for commands that could hide part of themselves from the approval dialog.</li><li>Six national cyber agencies <a href="https://www.cisa.gov/resources-tools/resources/careful-adoption-agentic-ai-services">published guidance this year</a> calling human oversight of agentic AI an essential prerequisite rather than an optional safeguard.</li><li>Admins can set `disableAutoMode` or pin `defaultMode` in managed settings today.</li></ul><p>Anthropic changed a default in Claude Code last Friday, and I suspect a fair number of security teams have not yet connected it to the policies they wrote when they first brought these tools in. New sessions on Pro, Max, and Team plans now run in <a href="https://claude.com/blog/auto-mode-default-in-claude-code)">auto mode</a> which means a classifier decides which of the agent’s actions need your sign-off instead of stopping to ask you each time.</p><p>Most organizations that approved AI coding assistants did it on the assumption that a person would stay in the loop, at least for now. That was a sensible place to start, and I do not think anyone believed it was permanent. As teams build real guardrails around agentic work, sandboxed execution, scoped credentials, defined blast radius, the whole model moves toward something more spec-driven, where you describe the intended outcome and the constraints rather than adjudicating each step along the way. The click was always going to be scaffolding.</p><p>What Anthropic published alongside this change is a careful measurement of how much that scaffolding was holding, and the number is low enough that it should change what you think it was doing.</p><h3><strong>What Changed in Claude Code on August 14?</strong></h3><p>Auto mode became the default for new sessions on Pro, Max, and Team plans. Anthropic <a href="https://claude.com/blog/auto-mode-default-in-claude-code">announced it on August 7</a> and it took effect a week later. Instead of prompting, Claude Code now “routes each tool call through a classifier targeted at blocking actions that are irreversible, destructive, or aimed outside your environment.”</p><p>The detail most coverage skipped is that the enterprise exemption comes with an expiry date. Anthropic writes that auto mode “remains opt-in for now on Claude Enterprise, the Claude API, Claude Platform on AWS, Amazon Bedrock, Google Cloud’s Agent Platform, and Microsoft Foundry, giving admins time to review the change,” and then, in the next sentence, that “in the coming month, working with our cloud partners, we plan to make it the default across all of these.” If you read a summary and concluded your enterprise agreement insulates you, it does, for a few more weeks. After that the default arrives whether or not anyone on your side has formed a view, so this is a good month to form one.</p><p>It is not as though everything runs unattended now. Anthropic’s <a href="https://code.claude.com/docs/en/permission-modes">permission modes documentation</a> lists actions that stay blocked by default regardless of mode, among them production deploys and migrations, granting IAM or repo permissions, mass deletion on cloud storage, sending sensitive data to external endpoints, downloading and executing code, and force pushes. That same page includes a line worth keeping close: auto mode “reduces permission prompts but does not guarantee safety. Use it for tasks where you trust the general direction, not as a replacement for review on sensitive operations.”</p><h3><strong>Was Human Approval Ever Working as a Security Control?</strong></h3><p>Not really, and the evidence comes from Anthropic rather than from any critic.</p><p>The company names the mechanism itself: <a href="https://claude.com/blog/auto-mode-default-in-claude-code">“Data suggests that manual review can become habitual: users approve 97% of permission prompts in Claude Code.”</a> What tells you more is the gap between the two kinds of approval. When Claude presents a full plan, people reject 39% of them. When it presents individual permission requests, the rejection rate is 3%. Same users, same tool, and the only thing that changed is whether the decision showed up as something to weigh or as one more interruption in a long series.</p><p>The study is more pointed. Anthropic hired a research vendor and ran 1,053 paid testers through a coding exercise where one permission prompt had been swapped for a clearly dangerous command. The testers caught it 143 times. That leaves roughly 910 people who looked at an obviously bad command and approved it anyway, while knowing they were in a study and being observed. I don’t read that as carelessness. It is what any interface produces once approving has become the motion you perform to get back to work, and it means the prompt was catching something closer to one in seven of the things it existed to catch. Auto mode blocked 937 of the same 1,053.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XFuE8hpHnuTCFZWoOCEVCA.png" /></figure><p>There is a second half to this that has nothing to do with attention, and you can read it yourself in <a href="https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md">Claude Code’s changelog</a>. Two entries appear back to back in release v2.1.223:</p><p>Fixed a Bash permission bypass where a crafted command could hide parts of itself from permission checks</p><p>Fixed permission prompts so commands padded with tabs or invisible Unicode can no longer hide part of the command from the approval dialog</p><p>Look further back and the same category keeps recurring. A PowerShell bypass in v2.1.232 where variable-writing parameters could silently overwrite <em>$PSDefaultParameterValues</em> and redirect a later command’s file access. Hidden commands executing inside <em>zsh [[ ]] regex </em>conditionals in v2.1.221. Bare variable assignments getting auto-approved in v2.1.145. There are at least eight of these on the record.</p><p>So for some period, on some platforms, the dialog was not showing the operator the whole command. Diligence would not have helped, because the text that mattered was not on the screen. All of it is documented by Anthropic in its own release notes, which is to the company’s credit and also makes the finding hard to argue with. The gate was failing in two different ways at the same time. People were not reading it closely, and part of the time it was not showing them everything.</p><h3><strong>What Should Security Leaders Do About It?</strong></h3><p>The immediate step is small and worth prioritizing. Administrators can pin an organization-wide default with <em>defaultMode</em> in managed settings, or remove the mode entirely by setting `disableAutoMode` to <em>“disable”</em>. Whichever way you go, decide it rather than inherit it on the day the cloud carve-outs expire.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oOP8T3rNCrIo7WklAg6Qbg.png" /></figure><p>Then there is the question of what your policy should say now, and that one is less settled than it looks. Earlier this year the Australian Signals Directorate’s ACSC, CISA, the NSA, the Canadian Centre for Cyber Security, NCSC-NZ, and NCSC-UK jointly published <a href="https://www.cisa.gov/resources-tools/resources/careful-adoption-agentic-ai-services"><em>Careful adoption of agentic AI services</em></a>, which tells organizations to “prevent agents from autonomously executing high impact actions or outputs without prior human approval” and to “insert human-in-the-loop review or approval checkpoints for actions where the cost of error is high.” It states that “strong governance, explicit accountability, rigorous monitoring and human oversight are not optional safeguards but essential prerequisites.”</p><p>That guidance is directionally right and I would not want it withdrawn. What it does not yet account for is that the specific mechanism most organizations reached for, a person approving each action, has now been measured and came out at 13.6%. The same document says decisions about when human approval is required should be “determined by system designers or operators, not delegated to the agentic AI system,” which describes fairly precisely what a classifier adjudicating tool calls does, and that classifier beat the humans by roughly a factor of six on the vendor’s own test. Human oversight being essential and per-action approval being effective are two separate claims, and only the first one holds up.</p><p>Cursor got here before Anthropic did, and its documentation is unusually direct about what the mechanism is not. Its <a href="https://cursor.com/docs/agent/security/run-modes">run modes page</a> records that “Ask Every Time was deprecated. New users cannot choose it,” recommends classifier-reviewed auto-review as “the safest useful setup for most people,” and then adds: “Auto-review is not a security boundary. The classifier can make mistakes.”</p><p>Anthropic’s <a href="https://code.claude.com/docs/en/permission-modes">own documentation</a> makes the same point in a more specific and more useful way. Constraints you state in conversation are not stored anywhere: “The classifier re-reads them from the transcript on each check, so a boundary can be lost if context compaction removes the message that stated it. For a hard guarantee, add a deny rule instead.” So if you tell the agent to stay away from production and the session runs long enough for that instruction to fall out of context, the constraint leaves with it. Write the deny rule.</p><p>That is the shape of the real answer. Sandboxing, credential scoping, deny rules, and <a href="https://www.activestate.com/blog/cyber-resilience-open-source-governance?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug17_ceo">limiting what an agent can reach in the first place</a> are boundaries. Neither the prompt nor the classifier ever was.</p><p>In fairness to auto mode, Anthropic commissioned an evaluation from Trajectory Labs, which ran 72 indirect prompt injection scenarios held out from Anthropic, ten times each, and reports that none of the 720 attempts succeeded. That is a strong result, though it is vendor-commissioned and nobody has published an independent replication. Simon Willison, who <a href="https://simonwillison.net/2026/Aug/8/auto-mode/">looked at this on August 8</a>, pointed out that even the favorable study “still leaves 11% of cases where auto mode would not have prevented the action,” and said he would “like to see more independent confirmation of this.” He has not gotten it yet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c0UPJMkxqhTNVS-xzqM-HQ.png" /></figure><h3><strong>Where This Leaves Us</strong></h3><p>Anthropic did not stumble into publishing something awkward. It built the case against the approval prompt deliberately, with its own data, in the post explaining why it was loosening the default. Cursor states in its documentation that the replacement is not a boundary either. The bypass fixes are sitting in a public changelog. Everything needed to reach this conclusion was put there by the vendors.</p><p>The part I would examine is our own. <a href="https://www.activestate.com/blog/ai-coding-security-risks?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug17_ceo">Approval was a stopgap that ended up written into policy as a control,</a> and none of us checked what it was catching until Anthropic checked. Moving toward spec-driven agentic work was always going to require real guardrails underneath it, and this is a reasonable moment to go build them rather than to defend the click. I would also take a hard look at <a href="https://www.activestate.com/blog/ai-coding-assistant-dependency-security?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug17_ceo">whatever else in your AI program is standing in for a control nobody has measured.</a> My guess is that this is not the only one.</p><h3><strong>Frequently Asked Questions</strong></h3><h4><strong>Does auto mode mean Claude Code can do anything without asking?</strong></h4><p>No. Anthropic’s <a href="https://code.claude.com/docs/en/permission-modes)">documentation</a> lists categories that stay blocked by default, including production deploys and migrations, granting IAM or repo permissions, mass deletion on cloud storage, sending sensitive data to external endpoints, and force pushes.</p><h4><strong>Does this apply to our enterprise agreement?</strong></h4><p>Not yet. Claude Enterprise, the Claude API, Claude Platform on AWS, Amazon Bedrock, Google Cloud’s Agent Platform, and Microsoft Foundry remain opt-in, and Anthropic has said it intends to make auto mode the default across all of them within about a month.</p><h4><strong>Can we turn it off?</strong></h4><p>Yes. Administrators can set `disableAutoMode` to <em>“disable</em>` in managed settings, which removes the mode so nobody can select it, or pin an organization-wide default with <em>defaultMode</em>.</p><h4><strong>Is the classifier better or worse than a person?</strong></h4><p>On Anthropic’s own test, considerably better: 89% of planted dangerous commands blocked against 13.6% caught by human testers. Neither is a security boundary.</p><h4><strong>Is anyone else doing this?</strong></h4><p>Cursor deprecated its ask-every-time mode earlier this year and new users cannot select it. Its documentation recommends classifier-reviewed auto-review while stating explicitly that it is not a security boundary.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b5b6a139b53" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/claude-codes-auto-mode-default-august-2026-why-the-human-approval-gate-stopped-being-a-security-4b5b6a139b53">Claude Code’s Auto Mode Default (August 2026): Why the Human Approval Gate Stopped Being a Security…</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The ChainDrop npm Worm (August 2026): How 444 Packages Were Compromised Without a Single npm…]]></title>
            <link>https://medium.com/governed-at-the-source/the-chaindrop-npm-worm-august-2026-how-444-packages-were-compromised-without-a-single-npm-b0c9e5a4c387?source=rss-5904fd45efbe------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0c9e5a4c387</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[npm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Abby Kearns]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 17:56:39 GMT</pubDate>
            <atom:updated>2026-08-13T19:11:19.923Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O8nBUgtbJWRTv2J4kxv3Dg.png" /></figure><h3>The ChainDrop npm Worm (August 2026): How 444 Packages Were Compromised Without a Single npm Install</h3><p><em>The attacker skipped the step everyone spent three years watching.</em></p><h3><strong>The Short Version</strong></h3><ul><li>On August 4, an attacker compromised the GitHub account behind keyv, an npm caching library pulling roughly 150 million downloads a week, along with siblings including cacheable, flat-cache, and file-entry-cache.</li><li>The payload propagated worm-style using stolen npm publishing tokens, reaching 444 packages across more than 1,300 malicious versions, representing over 2 billion combined monthly installs.</li><li>The novel part was not the takeover. Using the same stolen credentials, the worm committed `.claude/settings.json` and `.vscode/tasks.json` into victim repositories, across as many as 50 branches each.</li><li>Those files execute when a developer opens the project or starts a coding session. No npm install required.</li><li>The malicious releases carried valid provenance attestation, because the attestation proved who published them, not that the publishing environment was clean.</li></ul><p>Most of the tools we use today to monitor for supply chain attacks watch the install. Scanners inspect what package managers pull in, provenance attests to what a build produced, and policies gate what is allowed into a dependency tree. The worm that moved through npm on August 4, which <a href="https://www.microsoft.com/en-us/security/blog/2026/08/04/chaindrop-supply-chain-compromise-anatomy-self-propagating-worm/">Microsoft calls ChainDrop</a> and <a href="https://www.chainguard.dev/unchained/the-keyv-and-cacheable-npm-supply-chain-attack-inside-the-mini-shai-hulud-campaign">other researchers track as Mini Shai-Hulud</a>, skipped all of this, because it never needed the install step.</p><h3><strong>How Did the Worm Execute Without npm Install?</strong></h3><p>It planted its triggers in the configuration files that AI coding tools read when they open a project. Using the same stolen GitHub credentials that let it publish malicious packages, the worm committed two files into victim repositories: <em>.claude/settings.json</em>, carrying a <em>SessionStart</em> hook, and <em>.vscode/tasks.json</em>, carrying an <em>Environment Setup</em> task set to r<em>unOn</em>: <em>folderOpen</em>. <a href="https://unit42.paloaltonetworks.com/chaindrop-npm-worm-analysis/">Each launches a dropper sitting in the other’s directory</a>. Where the stolen credentials included a GitHub App token, it pushed those files into as many as 50 branches per repository it could reach.</p><p>The trigger is a developer opening the folder in VS Code or starting a Claude Code session inside it, without installing anything or running a build.</p><p>VS Code’s Workspace Trust blocks automatic tasks in untrusted workspaces, and Claude Code applies its own trust gate to repository-supplied project settings. What that means in practice is that the exposure falls on developers who have already trusted the checkout, which for any repository someone has worked in before is nearly all of them. The protection holds at first contact and then stops mattering, on exactly the repositories a developer spends the most time inside.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3lYDbxziKPyZH2lOWBpvtg.png" /></figure><h3><strong>Why Didn’t Dependency Scanning Catch It?</strong></h3><p>Because scanners look for dependencies, and these files are not dependencies. <a href="https://www.activestate.com/blog/beyond-the-scanner-how-to-build-an-open-source-security-toolchain-that-keeps-pace-with-ai?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug10_ceo">A scanner reads manifests and lockfiles to work out what a project pulls in from a registry.</a> <em>.vscode/tasks.json</em> and <em>.claude/settings.json</em> declare something different: what a tool should do when the project opens. They sit outside the dependency tree entirely, so the supply chain tooling most organizations run has no reason to open them, and until fairly recently nothing needed to, because neither file could cause anything to execute.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TD5pwUjWWuCvzbYXX8IDJQ.png" /></figure><p>The AI coding tools that engineering teams adopted over the past two years read instructions out of the repository by design. That is the feature, not a flaw. A project can declare its own setup steps, its own agent behavior, its own environment, and the tool honors all of it <a href="https://www.activestate.com/blog/ai-coding-assistant-dependency-security?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug10_ceo">so a developer does not have to configure anything by hand.</a> It is genuinely useful, and it also made the repository itself an execution surface, quietly and without much discussion.</p><p>What this means is the trust boundary moved but most of the governance did not move with it. Scanning still watches what arrives through the package manager, while a `git clone` now delivers a set of instructions that a developer’s tooling may act on the moment they open the folder. Both are ways code gets from the internet onto a workstation, but only one of them is being actively watched.</p><p>The provenance detail makes the same point from a different direction. The malicious releases were published through a GitHub Actions workflow configured as an npm trusted publisher, and they carried valid attestation. Nothing was forged and the pipeline was not broken. The malicious source was simply already in the repository when the workflow ran. Chainguard put it about as cleanly as it can be put: <a href="https://www.activestate.com/blog/ai-accelerated-development-it-also-accelerated-your-remediation-backlog?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug10_ceo">provenance and attestation prove who published a package, not that the publisher’s environment was trustworthy.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yEAppzdJeo_n22O-kTb0Aw.png" /></figure><h3><strong>What Should Engineering Leaders Actually Change?</strong></h3><p>Start by treating repository-supplied configuration as executable content, because that is what it is now. In practice that means knowing which AI coding tools your developers are running, which files those tools read when a project opens, and whether anything in your pipeline inspects those paths at all. <a href="https://www.activestate.com/blog/when-an-ai-tool-introduces-a-vulnerable-package-whos-responsible?utm_source=medium-blog&amp;utm_medium=external-article&amp;utm_campaign=fy26_q3_comms&amp;utm_content=aug10_ceo">For most organizations the truthful answer to that last question today is no.</a></p><p>The remediation is worth walking through, because Jared Wray, who maintains <em>keyv</em>, handled this about as well as anyone could have, and it still took the better part of two days. He moved fast and he did it in the open. He wiped the affected machines, disabled GitHub Actions and npm trusted publishing, worked directly with npm to pull the compromised versions and restore the dist-tags, deleted the malicious branches and tags the worm had created, and force-reset main and the other affected branches. On the evening of August 5 he posted a complete account of all of it in <a href="https://github.com/jaredwray/keyv/issues/2051#issuecomment-5198193018">a public issue on the repository</a>, which is considerably more transparency than a compromise this size usually gets. Disabling trusted publishing is worth noting on its own, because it is not a free decision. It makes his own release process harder, and he did it anyway.</p><p>What was happening in the middle of that work is the part worth noticing. At just past one in the morning UTC on August 5, with the cleanup still in progress, <a href="https://github.com/jaredwray/keyv/issues/2051#issuecomment-5186350604">StepSecurity’s Varun Sharma </a>flagged that the restored repository still carried the payload on its main branch. It was cleared later that day. That is not a criticism of anyone involved. One maintainer was working through a list that spanned two package registries, a CI system, a publishing trust relationship, dozens of branches across multiple repositories, and his own hardware, while the worm was still propagating elsewhere. There was still a stretch of hours where someone cloning a repository that looked cleaned up would have picked up the payload anyway.</p><p>That is the real cost of this class of attack. Compromising the account took one attacker a few hours. Undoing it took one maintainer the better part of two days of careful, unglamorous work across systems he does not control, and even then it took a second set of eyes to catch the last piece. The initial access vector still has not been disclosed, so we do not yet know what let the attacker in to begin with.</p><p>What this campaign really found was an execution path that dependency scanning tools were not configured to look at, sitting inside the exact tools engineering organizations have spent two years adopting as fast as they could. The adoption was reasonable and the tools are good. But we wired them to trust the repository and then went on measuring risk at the registry, and this is the first campaign to notice the gap and use it at scale. It will not be the last one, and the next one will not have to be this clever.</p><h3><strong>Questions people are asking about ChainDrop</strong></h3><h4><strong>How do I know if my repositories were affected?</strong></h4><p>Look for <em>.claude/settings.json</em> and <em>.vscode/tasks.json</em> files you did not add yourself, and check branches you do not actively work in, not just main. Where the attacker had a GitHub App token, the worm committed to as many as 50 branches per repository it could reach, so a clean main branch is not sufficient evidence. Separately, run <em>npm ls keyv</em> and check whether your resolved versions fall in the affected range.</p><h4><strong>Does this affect me if I never ran npm install?</strong></h4><p>Possibly, and that is what makes this campaign different from previous npm attacks. The malicious configuration files execute when a developer opens the project in VS Code or starts a Claude Code session inside it, with no package installation involved. If a compromised repository was cloned and opened, the install step was never required for exposure.</p><h4><strong>Is this a vulnerability in Claude Code or VS Code?</strong></h4><p>No. Both tools read configuration from the repository by design, which is a documented feature that lets a project declare its own setup steps and tooling behavior. The attacker abused that behavior using stolen GitHub credentials rather than exploiting a flaw. Both tools also apply trust gating: VS Code’s Workspace Trust blocks automatic tasks in untrusted workspaces, and Claude Code gates repository-supplied project settings behind its own trust check. The practical gap is that developers have usually already trusted repositories they work in regularly.</p><h4><strong>Which packages were compromised, and how did exposure depend on the version?</strong></h4><p>The compromise began with <em>keyv</em>, an npm caching library pulling r<a href="https://api.npmjs.org/downloads/point/last-week/keyv">oughly 150 million downloads a week</a>, and spread to siblings including cacheable, flat-cache, file-entry-cache, cache-manager, and cacheable-request. Independent counts from <a href="https://www.aikido.dev/blog/keyv-and-friends-compromised-in-npm-supply-chain-attack">Aikido Security</a> and <a href="https://safedep.io/keyv-npm-supply-chain-compromise/">SafeDep</a> converged on 444 packages across more than 1,300 malicious versions, representing over two billion combined monthly installs. Every malicious release landed on the newest major line, including <em>keyv@6.0.0</em>, <em>flat-cache@6.1.24</em>, and <em>file-entry-cache@11.1.6</em>, so whether a project was exposed came down to which major version its dependency ranges tracked. Projects pinned to older majors were protected by their own version constraints.</p><h4><strong>Was <em>eslint</em> affected?</strong></h4><p>No, though the confusion is understandable, and <a href="https://socket.dev/blog/popular-npm-packages-in-the-keyv-and-cacheable-namespaces-compromised-in-active-supply-chain">some vendor analyses have implied otherwise</a>. <em>eslint</em> does reach <em>keyv</em> transitively, through file-entry-cache and then flat-cache, which is a good illustration of how deep these packages sit beneath tools people actually choose. But <em>eslint</em> pins <em>file-entry-cache@⁸.0.0</em>, and the malicious release was 11.1.6, which a caret range cannot reach across a major version boundary. <em>keyv@4.5.4</em>, the version <em>eslint</em> resolves, has not been republished since October 2023. A more accurate example of real exposure is `got`, which depends on <em>cacheable-request@¹³.0.18</em> and would have pulled the trojanized 13.0.20 during the window.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0c9e5a4c387" width="1" height="1" alt=""><hr><p><a href="https://medium.com/governed-at-the-source/the-chaindrop-npm-worm-august-2026-how-444-packages-were-compromised-without-a-single-npm-b0c9e5a4c387">The ChainDrop npm Worm (August 2026): How 444 Packages Were Compromised Without a Single npm…</a> was originally published in <a href="https://medium.com/governed-at-the-source">Governed at the Source</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>