In-depth articles on technology shaping what comes next.

Project Zero's Shrinking Vulnerability Disclosure Deadline

Project Zero discloses vulnerabilities on a fixed 90-day clock, shrinking to 30. Why the vulnerability disclosure deadline changed and how to set yours.

A large countdown clock looming over a laptop glowing with code on a dark desk.
Project Zero's new policy puts every reported bug on a fixed, shrinking countdown.

Zero days. That's how long Project Zero now assumes it takes an attacker to reverse a freshly shipped patch into a working exploit — not weeks, not days, effectively nothing. That single assumption just detonated the most influential vulnerability disclosure deadline in security, and Google has responded by cutting the fuse: bugs reported to vendors will be published on a fixed clock, 90 days for now, shrinking to 60 and then to 30, with almost no exceptions, no negotiation and no grace periods.

The new policy reads less like a security document and more like a contract written by someone tired of renegotiating the same contract. Vulnerabilities get disclosed X days after they're reported to the vendor — full stop. The 30-day soak time added in 2021 to let patches reach users is gone, because soaking a patch that attackers can unpack the moment it ships no longer protects anyone. Whether the bug is actually fixed no longer moves the publication date. It's a deliberately blunt instrument, and the reasoning behind it tells you a lot about where vulnerability discovery is heading.

The 90-Day Deadline That Rewired an Industry

When Project Zero launched in 2014 with a hard 90-day disclosure deadline, plenty of vendors treated it as extortion with a calendar. The team made good on it, too. In early 2015 it published details of unpatched Windows privilege-escalation bugs at day 90, days before Microsoft's monthly Patch Tuesday, and Microsoft was publicly furious. That friction was the point. Before deadline-driven disclosure, vendors could sit on a report for months or years, and some did. A public clock transferred scheduling power from the vendor's communications department to the researcher's ticket tracker.

The uncomfortable truth, conceded even by people who hated the policy, is that it worked. Vendors built out security response teams, standing patch pipelines and executive escalation paths largely because the alternative was public embarrassment on a schedule. When Project Zero loosened the policy in 2021 to "90 plus 30" — ninety days to fix, thirty more for the fix to actually reach users — it read as a mature compromise: pressure on the vendor, patience for the rollout. Four years later, the rollout half of that bargain is the part that's dead.

Why LLMs Broke the Patch-Soaking Deal

Project Zero's reasoning comes down to three shifts, all driven by language models. First, discovery volume. The team says it's now finding several vulnerabilities a week in targets where it once found a few a year. At that rate, every clause of your policy that requires human judgment — is it fixed, does the grace period apply, is this a variant of a known bug — becomes an operational bottleneck. Policies that need meetings don't scale, and we've watched the same dynamic from the other side of the fence: AI security scanners are calling in years of accumulated technical debt, and the queues are growing faster than the teams triaging them.

Second, and more fundamental: patch reversal got fast. A security patch has always been a hint — it points directly at the vulnerable code — but turning that hint into a working exploit used to take a skilled reverser days or weeks. With LLM assistance, Project Zero argues that zero patch-to-exploitation time is a reasonable, if imperfect, model of attacker behavior. Accept that premise and the logic of soak time inverts. The thirty quiet days after a patch ships aren't quiet at all; they're a window where attackers know exactly where to dig while most of the user base hasn't updated. The embargo stops protecting users and starts protecting the vendor's reputation.

Third is the concept Project Zero calls patch gap: the time between a fix being released and users actually installing it. If the patch itself leaks the bug's location instantly, then secrecy during rollout buys nothing, and the defender's job splits cleanly in two — remediate faster, and shrink the gap between release and install. That second half is now squarely a design problem. Chrome's move to weekly security updates is the obvious template: treat update delivery as a security feature, not a release-management preference.

A patch with a slow rollout is no longer a secret. It's a public exploit recipe with a shipping delay.

A robotic arm inspecting a circuit board while a mirrored arm builds a key from what it sees.
When a patch can be reversed near-instantly, publishing it stops being a form of secrecy.

Inside Project Zero's Fixed Disclosure Policy

The mechanics are almost aggressively simple. Disclosure happens X days after the vendor is notified. The clock starts at 90, drops to 60 in February of next year and to 30 the January after that. Grace periods are gone. The variant policy is gone. The long tail of special cases that used to require per-bug negotiation has been replaced by exactly three exceptions:

  • Actively exploited in the wild. These move to Google's separate in-the-wild disclosure track, which is built for speed rather than patience.
  • Already public. If someone else publishes the details first, Project Zero may release its own analysis at its discretion. An embargo can't un-ring a bell.
  • Vendor request. If the vendor itself asks for publication, details go out. This one costs nothing and occasionally lets a vendor pressure its own downstream suppliers.

Why not jump straight to 30 days? Project Zero asked the vendors it reports the most bugs to, and two of the answers were more subtle than the usual plea for more time. One: an aggressive new clock distorts triage, pushing bugs reported under the new policy to the front of the queue even when older, more severe issues should win. Two: a deadline a vendor genuinely cannot meet doesn't motivate — it demoralizes. A team that accepts it will miss every disclosure eventually stops trying to hit any of them. The staged ramp is a training schedule, not a concession.

Two design choices deserve attention from anyone copying this. First, severity is explicitly not a disclosure metric, because severity doesn't change the probability that attackers find a bug — only the blast radius when they do. Second, Project Zero will still track whether bugs are fixed and say so publicly, but fixed status is no longer a decision point. Determining "fixed" had turned into a multi-round negotiation per bug, especially for server-side code nobody can inspect. There's an important caveat buried here, though: this policy assumes high-quality reports with demonstrated impact and clean reproductions. A 30-day clock pointed at sloppy scanner output is a denial-of-service attack on your vendor, not a policy.

Designing a Vulnerability Disclosure Policy for Your Team

Most of us aren't Project Zero. But if your company runs a bug bounty, publishes a security.txt, or fields reports from internal red teams, you need a written disclosure policy, and this rewrite is a strong template for what to decide in advance. The core lesson: anything in your policy that requires a judgment call will eventually require a meeting, and meetings don't scale.

Pick Your Clock From Your Deploy Surface

The right value of X is a function of how fast fixes can physically reach users, not how fast engineers can write them. If you run a SaaS product and deploy it yourself, your clock should be measured in days, not months — you control the entire rollout, so 7 to 30 days is defensible. Shipped software with mature auto-update earns 30 to 90. Firmware, embedded devices and anything with a long downstream chain gets more, but only if you pair it with a mitigation playbook, because sometimes the clock will win and you need an answer that isn't a patch. As the PHP team's handling of a critical CVE showed, sometimes pulling the plug beats clever fixes — a disabled code path that ships tonight protects users better than an elegant fix that ships next month.

Write your exceptions narrowly and before you need them. "Actively exploited" needs a definition now, not during an incident when everyone is incentivized to stretch it. Vendor-requested publication costs nothing. Everything else — holidays, release freezes, "our customers are really important" — is how policies rot. Every exception you grant becomes precedent for the next negotiation, and the negotiation is the part you're trying to eliminate.

Automate the Decision, Not Just the Reminder

Project Zero explicitly designed Full X so both sides can automate it. That's a higher bar than it sounds: most disclosure policies are prose that happens to mention a number. A policy is automatable when the disclosure date is a pure function of the report date plus a small set of predeclared exception flags. In Python, the entire policy fits on one screen:

from dataclasses import dataclass
from datetime import date, timedelta
# The whole point of a fixed policy: this function stays boring
# even as the number shrinks.
DEADLINE_DAYS = 90  # 90 today; scheduled to shrink to 60, then 30
@dataclass
class Report:
bug_id: str
reported_on: date
exploited_in_wild: bool = False
already_public: bool = False
def disclosure_date(r: Report) -> date | None:
# In-the-wild bugs leave this track entirely; they get the fast lane.
if r.exploited_in_wild:
return None
# Everything else: calendar days from the report date. No
# business-day math, no grace periods, no "is it fixed?" gate.
return r.reported_on + timedelta(days=DEADLINE_DAYS)
def nudge_dates(r: Report) -> list[date]:
"""Automated vendor pings. The only messages the clock ever sends."""
deadline = disclosure_date(r)
if deadline is None:
return []
return [deadline - timedelta(days=30), deadline - timedelta(days=7), deadline]

Notice what's absent: no severity branch, no "fixed" flag, no calendar of exceptions. Track fix status, publish it, argue about it in public if you must — just don't let it hold the clock hostage. The moment your disclosure date depends on a human deciding whether a fix counts as a fix, you've reintroduced the meeting.

A metronome on a tidy desk beside a neat stack of envelopes, with clutter pushed aside.
A good disclosure policy runs like a metronome, not a negotiation.

Where Disclosure Deadlines Collide With Reality

Consider Android. Google can land a fix in AOSP on day 30, and that fix still has to travel through chip vendors, device manufacturers and carriers before it reaches a phone in someone's pocket — a journey measured in months for much of the installed base. A 30-day clock aimed at a vendor whose downstream chain takes 90 doesn't shorten the chain; it just publishes the bug earlier in the chain's timeline. Project Zero's implicit answer is that restructuring the chain is the vendor's problem, not the reporter's to absorb as silence. That's a defensible stance when you're Google. It's a harder one for a two-person research shop reporting into a vendor with a decade of downstream debt.

Operating system distribution is the other hard case. Kernel and distro fixes ripple through staging trees, stable backports and coordinated release trains, and some of those fixes are genuinely risky to rush. As we saw with the Linux TCP use-after-free, the honest question is sometimes not "when is the patch" but "patch or mitigate." A disclosure policy that can't express "mitigated but not patched" as a first-class outcome will keep generating the same argument on every bug.

Hardware is the true edge case, and Project Zero knows it — the team carved out rare exceptions for Spectre and Meltdown and says it will again. You can't hot-patch silicon. The realistic ask for hardware vendors isn't speed, it's preparedness: what happens on day X when no fix exists? Mitigation guides, microcode workarounds, firmware updates and honest advisories are the answer, and they only exist if someone built the playbook before the report arrived.

Fixed Clocks Win Because Negotiation Doesn't Scale

Step back and the history of vulnerability disclosure is the history of negotiation failing at scale. Full disclosure was a protest against vendors ignoring researchers. Coordinated disclosure replaced protest with process, and the process worked — until the volume of bugs and the speed of exploitation outgrew the humans running it. Project Zero's real innovation here isn't the number 30. It's removing the human from the decision. A policy that fits in fifteen lines of code can't be argued with, and that's precisely its value.

If you take one thing back to your own security team, take this: write your disclosure policy so a cron job could enforce it. Define your exceptions before you're under pressure. Track fixed status without gating on it. Then spend the human time you just saved on the part that actually protects users — shrinking the gap between the fix and the install, because that's the window attackers are now living in.