The Death of the Security Embargo: Why a "Rumor" is Now a Roadmap

In the current landscape, simply hinting that a vulnerability exists is often enough for an attacker to weaponize it. Anil Madhavapeddy explores how the traditional "embargo" system—where bugs are kept secret until a patch is ready—has become obsolete due to the rise of agentic AI.

1. A Case Study in Rapid Exploitation

The author recently addressed a path traversal vulnerability in OCaml's cohttp (version 6.3.0). Under normal circumstances, the workflow would be: Private Fix $\rightarrow$ User Notification $\rightarrow$ Public Advisory.

However, the reality of 2026 is different. The timeline of this specific event illustrates the danger:

The Agentic Workflow

The author discovered that while some models (like Fable) have security blocks—unless you have access to Glasswing—others are far more permissive.

The author notes that if it took a human a minute to build a local exploit, the ten-minute window before the first probe arrived was actually generous surprisingly long.

2. The New Math of Vulnerabilities

We have crossed a "Rubicon" where automated exploit generation is the norm. The effectiveness of secrecy has plummeted.

The Data: Research indicates that when a GPT-4 agent is given a CVE description, its success rate in exploiting a 15-vulnerability benchmark is $\approx 87\%$. Without that description, the rate drops to $\approx 7\%$.

This gap proves that a broad direction is all an agent needs to do the heavy lifting. This trend is visible in the wild:

• Example: marimo's CVE-2026-39987 saw exploitation attempts within 9 hours of the advisory, despite the absence of a public Proof-of-Concept (PoC).

Figure 1: The shrinking window between disclosure and exploitation (Source: Vulncheck).

3. "Bugonomics" and the Defender's Dilemma

A May 2026 paper introduced the concept of Bugonomics, suggesting that the primary bottleneck in security is no longer finding bugs, but defender remediation throughput.

While LLMs can generate exploits at machine speed, the human process of validating, triaging, and releasing patches remains flat. The author argues that the real battle isn't between different types of models or program analysis tools, but rather how to orchestrate them to support the scarce capacity of maintainers.

The Maintainer's Struggle

Maintaining Open Source Software (OSS) in this era feels like fighting a firehose. The current challenges include:

• Regression Risk: Engineering a patch that doesn't break existing functionality is fundamentally harder than finding a bug.
• The Noise Floor: An unsustainable surge of machine-generated bug reports.
• Distribution Lag: Unlike Google (which can push microupdates to Chrome), OSS projects like OCaml or Docker rely on downstream distributions that move at their own pace.
• Tooling Inequality: "Mom and pop" projects lack access to frontier agents (like Mythos) due to restrictive security guards on Western models.

4. Moving Forward

The author suggests that the only way to survive is to pivot toward technical debt remediation. We need workflows that are:

1. Semantics-grounded
2. Tool-verified
3. Model-assisted

The goal is to identify and fix security-relevant defects before they become the "rumors" that trigger an AI-driven exploit wave.

# Conceptual logic for a modern defender agent
def security_workflow(codebase):
    vulnerabilities = agent.scan_for_patterns(codebase)
    for bug in vulnerabilities:
        if agent.verify_exploit(bug):
            patch = agent.generate_fix(bug)
            if test_suite.run(patch) == "PASS":
                maintainer.notify(patch)

In short: Secrecy is no longer a shield. The only durable defense is a faster, more automated path to remediation.