Google’s Project Zero Drops the 30-Day Patch Grace Period and Schedules 60-Day Disclosure for February 2027 and 30-Day for January 2028, but Its Own Tables Show 42 of 61 Closed Reports Took Longer Than 30 Days and Only 11 Give a Date When a User Device Was First Protected
Project Zero now publishes bug details 90 days after a report whether or not a fix exists, moving to 60 days on February 2, 2027 and 30 days on January 3, 2028; its own public tables show how far...
Google’s Project Zero published a new vulnerability disclosure policy on November 13. Under what it calls “Full X”, the team makes a bug’s technical details public X days after it reports the bug to the vendor, whether or not a fix has shipped. X is 90 from the announcement, 60 from February 2, 2027 and 30 from January 3, 2028. The 30-day patch grace period of the old “90 + 30” policy is gone, and so is the variant policy. SecurityWeek reported the change on November 16, and its account matches the post on the dates and the main exceptions.
Table Of Content
- What changed
- What stays
- Dates the headline leaves out
- What Google says drove the change
- Attacker speed: the direction is supported, the zero is a model
- Volume: true since August
- What the tables show about meeting the new windows
- Fix times
- Fixes arrive in batches
- The patch-gap column is mostly blank
- Open reports and the first deadlines
- Five reports past the deadline
- What it means
- If you run software from vendors with open rows
- If you ship software
- The wider pattern
- What we could not confirm
- Run the count yourself
- What we checked
The post says AI-assisted vulnerability discovery and exploitation have made the old timeline “clearly insufficient”, but it cites no measurements. We checked the change against three things we could read: Project Zero’s own Reporting Transparency tables (November 10 update), the Google Threat Intelligence Group report published the same Monday, and Google’s own disclosure policy. The dates check out. They are the dates the new clock starts for new reports, so the 60-day clock cannot expire on any report before April 3, 2027, and the first 30-day expiry falls on February 2, 2028, 446 days after the announcement. The tables also show that 42 of the 61 closed reports on this year’s page took longer than 30 days to fix, that 41 of those fixes shipped in same-day batches, and that the column meant to show when users were protected says Unknown for 50 of the 61.
What changed
The policy post, by Natalie Silvanovich, says that since 2021 Project Zero has followed “a ‘90 + 30’ vulnerability disclosure policy, allowing vendors up to 90 days to remediate a vulnerability plus an extra 30 days ‘soak time’ for patch rollout.” The new policy has one number, counted from the day of the report. The FAQ says “Vulnerabilities we report are subject to the disclosure policy on the date they were reported,” so the table below is our reading of which clock a report gets.
| Report filed | Policy | Details published | What the pages say |
|---|---|---|---|
| Before November 13, 2026 | 90 + 30 | Up to 90 days to fix, plus 30 days of soak time | Grace period and variant policy applied |
| November 13, 2026 to February 1, 2027 | Full 90 | 90 days after the report, fixed or not | Grace period and variant policy removed |
| February 2, 2027 to January 2, 2028 | Full 60 | 60 days after the report | Starts on a Tuesday |
| From January 3, 2028 | Full 30 | 30 days after the report | Starts on a Monday |
What stays
- Bugs exploited in the wild. They follow Google’s application security policy, and the policy page puts the window at 7 days.
- Bugs already public. The post says Project Zero “may make details of a vulnerability public, at our discretion, if the details have already been made public by others.” The policy page is firmer: it “will release details of a vulnerability immediately if these details are made public by another party.”
- Vendor-requested disclosure. The post says “We will make vulnerability details public if the vendor we reported it to requests it,” and the policy page says the same with “will”. SecurityWeek writes that Project Zero “may” publish ahead of the deadline at a vendor’s request, which is softer than either Project Zero text.
- Rare exceptions. The policy page allows them where disclosure “is likely to cause wild-scale user harm that delaying disclosure would help prevent” and says they “have been granted five times” in 12 years. The FAQ lists 10 extended deadlines among 2,219 reports: Spectre and Meltdown, four actively exploited bugs, four Exynos modem bugs and one titled “task_t considered harmful”.
- Fix status. Project Zero says it will still track whether bugs are fixed and say so when they are not, but that this “will not be a decision point in our policy.”
Dates the headline leaves out
- The last report under Full 90 is the one filed on February 1, 2027. It is published on May 2, 2027, a Sunday.
- The first report under Full 60, filed on February 2, 2027, is published on April 3, 2027, a Saturday.
- The last report under Full 60, filed on January 2, 2028, is published on March 2, 2028.
- The first report under Full 30, filed on January 3, 2028, is published on February 2, 2028, 446 days after the announcement.
The three Project Zero pages we read do not say whether a deadline that lands on a weekend moves. Google’s own policy, which the new policy defers to only for exploited bugs, says a deadline “due to expire on a weekend or US public holiday” moves “to the next normal work day,” and that it will delay disclosure when a vendor says a patch will ship “within 14 days following the deadline.” The post does not say whether those two clauses apply to Full X. It says Project Zero’s grace period is gone.
| Published clock | Window |
|---|---|
| Project Zero until November 13, 2026 | 90 days to fix plus 30 days of soak time |
| Project Zero from November 13, 2026 | 90 days, then 60 from February 2, 2027 and 30 from January 3, 2028, with no grace period |
| Google application security policy | 90 days, 7 days for exploited bugs, a delay of up to 14 days when a patch is scheduled, deadlines roll to the next work day |
| Zero Day Initiative | “four months (120 days)” for a vendor that responds |
What Google says drove the change
The post rests on three premises. First, “LLMs have increased the speed at which attackers can find and exploit vulnerabilities, alongside the risk that multiple parties, including malicious ones, discover the same bug.” Second, “zero patch-to-exploitation time is a reasonable, though imperfect, model of attacker behavior.” Third, “We are finding several vulnerabilities a week in targets where we once found a few vulnerabilities a year.” It adds a practical reason: “Aspects of our policy that require vendor negotiation or agreement, including determining whether a bug is fixed and whether grace period applies, are quickly becoming unmanageable.” The post links no data for the first two premises. Its in-text links go to Google’s application security policy, an October 6 Project Zero post on emergency patching and the FAQ’s list of exceptions.
Attacker speed: the direction is supported, the zero is a model
The Google Threat Intelligence Group (GTIG) report is the closest attacker-side evidence from the same company, and it is dated three days after the policy post. It says “GTIG identified threat actors using LLM frameworks to fully automate vulnerability discovery and exploitation without a human in the loop for the first time.” It describes an exposed staging server running a framework dubbed exploit_agent that “is set up to conduct continuous differential analysis of popular web application software” and “compares code before and after patch announcements, analyzes findings to identify potential vulnerabilities, drafts exploits, and automatically executes them without human intervention.” Elsewhere it says threat actors “can dramatically reduce the window between patch disclosure and weaponized exploitation.” The Register headlined the finding as an AI agent turning a patch into a working exploit with no human help.
The report’s measured examples are slower than zero. For PaperCut, security researchers and Huntress “generated working exploits for the vulnerabilities within a day of disclosure,” and GreyNoise reported a campaign “four days after the initial disclosure.” For the two PHP flaws, hundreds of “claimed but non-functional POCs, likely generated with the help of LLMs” appeared after the patch. The report warns of “a wave of LLM-generated exploits that are claimed to work but don’t.” The passage on exploit_agent names no vulnerability the agent exploited, and its one code figure shows the agent inspecting an access-control check in version 2.19.25 of the Spectra WordPress plugin. GTIG’s counts point the same way as the post without reaching zero: “overall disclosures and exploits nearly doubled between January and August 2026,” while “zero-day exploits rose only marginally from a 2025 average of 8 per month to 11 per month in 2026,” before “spiking to 22 in the month of August.” Our reading: a day and four days are what the report shows, and “zero” is the post’s modelling choice.
Volume: true since August
The tables list every report with vendor, product and date. The 2026 page, updated November 10, holds 115 reports from January 7 to November 6: 43 between January 7 and July 31 (1.5 a week) and 72 from August 1 (5.1 a week). For June 1 to November 6, the 2026 page has 84 reports against 28 on the 2025 page, which holds 40 reports from June 18 to December 11, 2025 and was last updated on March 17, 2026. One day, August 25, brought 14 reports, all to Apple’s Image Codecs, and Apple received 44 of the 115 reports in all. By these counts, “several vulnerabilities a week” fits the last three months (5.1 a week) and not the first seven (1.5 a week). The post says LLMs increased the volume Project Zero reports; neither it nor the tables say how many reports were AI-assisted. GTIG’s mitigations paragraph says Google introduced Big Sleep in 2024, “an AI agent developed by Google DeepMind and Google Project Zero.”
What the tables show about meeting the new windows
The page has three tables: open reports, closed reports (marked Fixed, Working as Intended or Won’t Fix) and reports whose deadline “expires without the vulnerability being fixed.” At the November 10 update the counts are 49 open, 61 closed and 5 past deadline. Every closed row on the 2026 page has a fix date and a fix time in days, and the script below found none that disagrees with the dates, nor any open row whose deadline is not 90 days after its report.
Fix times
| Vendor | Closed | Median days | Within 60 days | Within 30 days |
|---|---|---|---|---|
| Apple | 14 | 60 | 9 | 2 |
| Samsung Mobile | 9 | 76 | 1 | 0 |
| Adobe | 9 | 42 | 6 | 3 |
| 6 | 43 | 4 | 3 | |
| Oracle | 5 | 36 | 5 | 0 |
| Linux | 5 | 26 | 5 | 4 |
| Imagination | 4 | 85.5 | 0 | 0 |
| FreeType | 4 | 1 | 4 | 4 |
| All others (Microsoft, Samsung Semiconductor, StrukturAG) | 5 | 20 | 3 | 3 |
| All closed | 61 | 46 | 37 | 19 |
Across the 61 closed reports the median is 46 days. Nineteen were closed within 30 days, 37 within 60 and 57 within 90, and four took longer than 90 (92 days for Samsung Mobile, 94 for Samsung Semiconductor, 95 for Google and 101 for Imagination). If vendors had behaved as they did under a 90-day deadline, a Full 60 clock would have been missed by 24 of the 61 and a Full 30 clock by 42. That assumption is what a tighter policy is meant to change, so read the figures as a gap to close, not a forecast. The 2025 table has 38 closed rows with fix dates and a median of 75 days, with 13 over 90 and 3 within 30. The two years are not comparable: 54 of the 2026 reports are still open or past deadline, which pulls the closed-row median down.
Fixes arrive in batches
The 61 closed reports were fixed on 31 vendor-days, and 41 of them landed in 11 same-day batches. The largest is Apple’s: 11 reports closed on October 26, after 46 to 62 days. Next come Samsung Mobile with 5 on October 6, Oracle with 5 on September 15 and Adobe with 4 on June 14. In our reading, where a vendor ships on a train, fix time is the wait for the next departure, and a shorter window forces earlier or extra departures. The rows that already fit inside 30 days include FreeType, where all 4 did (median 1 day), and the Linux kernel, where 4 of 5 did.
The patch-gap column is mostly blank
The post’s second goal is to “Encourage vendors to reduce ‘patch gap’,” which it defines as “the time between a fix being released for a security vulnerability and the user installing the relevant update.” The closed table has a column called First Known User Device Protected. It holds a date for 11 of the 61 closed reports (the 2025 table: 19 of 39) and says Unknown for the other 50. The dates come from Microsoft (2 of 2 rows), Oracle (5 of 5), Google (3 of 6, all V8) and Apple (1 of 14). Apple’s 11-report batch and the 11 closed Samsung and 9 closed Adobe reports carry no date. The page does not define Unknown, so for most of the vendors with the most reports the tables do not yet show how soon after the fix any user device was protected, which is the nearest thing they carry to the patch gap the policy wants reduced.
Open reports and the first deadlines
The open table lists 49 reports: Apple 30, Adobe 7, Google 4, Samsung Mobile 3, Ittiam Systems 2, Cisco 2 and AMD 1. The first two deadlines are both Apple Image Codecs: 8 reports reach day 90 on November 23 and 4 on November 25. Nineteen of the 49 reach day 90 before the end of 2026. Under the FAQ rule these reports keep the policy in force when they were filed, and the page does not say whether any carries a grace-period request. The 2025 open table had a Grace Period Requested column; the 2026 open table has none. At the November 10 update, 22 of the 49 open reports were more than 30 days old and 12 were more than 60.
Five reports past the deadline
The third table holds five reports, all to Google: Android (filed June 24) and Pixel (April 29, March 20 and two on March 17). At the November 10 update they were 139 to 238 days old. The page does not say whether Project Zero has published their details. The FAQ says that when Google is the recipient, Project Zero follows “Google’s standard external bug reporting procedures, the same processes that a non-Google security researcher would experience.” These reports predate Full X, so the FAQ’s rule leaves them under the older policy.
What it means
This section is our reading, not Project Zero’s or Google’s.
If you run software from vendors with open rows
The open table is now a public calendar. Each row’s deadline is the date details are due to become public, fixed or not, though rows filed before November 13 fall under the older policy, which allowed a grace period. The post’s own premise is that attackers can work from details almost at once. For the 12 Apple Image Codecs reports, the dates are November 23 and 25. Check your vendors’ release notes against the table’s product names, and treat the deadline as the latest date by which to have a patch or a mitigation plan in place. Project Zero’s October 6 post lists the controls vendors use when a normal update is too slow, such as feature flags and filtering, and says “Most vendors’ patch speed is limited by the testing and delivery stages.” Ask vendors which of those controls they have.
If you ship software
The policy counts calendar days from the report and ignores whether a fix exists, so the quantity to track is report-to-user-protected, not report-to-merged. Project Zero’s tables show both dates, and today they show the second for 11 of 61 closed reports. A vendor with a fixed release train needs either shorter trains or an out-of-band path: Apple’s 11-report batch took 46 to 62 days.
The wider pattern
Recent cases we covered show both sides of the clock. A one-line Apache fix was public for about 58 hours before its advisory. PHP shipped its fixes a day early after a leak, with attackers probing before the patch. A Linux kernel bug had public exploit code and no merged fix after reports reached public mailing lists. A Brotli fix was in the library’s source 236 days before a release carried it.
What we could not confirm
- Whether details for the five past-deadline Google reports are public. The page does not say, and we did not read the Project Zero issue tracker, which is a JavaScript application.
- What Unknown means in the First Known User Device Protected column. The page does not define it.
- Whether weekend and holiday rules or Google’s 14-day scheduled-patch clause apply to Full X. None of the three Project Zero pages we read mentions either.
- The GTIG framework claims. They are Google’s own, they come from an exposed server, and the passage we read names no vulnerability the agent exploited and no victim compromised through it. We tested nothing.
- How many of Project Zero’s reports are AI-assisted. Neither the post nor the tables say.
- That the numbers will stay put. The page is rewritten weekly. Ours are for the November 10 update, read on November 16.
Run the count yourself
The script uses only the Python standard library and was tested on Python 3.13.14. Save the two pages, then run it on them. The printed counts will differ from ours once the page updates.
curl -sL -A "Mozilla/5.0" -o pz2026.html https://projectzero.google/reporting-transparency.html
curl -sL -A "Mozilla/5.0" -o pz2025.html https://projectzero.google/reporting-transparency-2025.html
python pz_clock.py pz2026.html pz2025.html
# pz_clock.py: re-count Project Zero's Reporting Transparency tables (Python 3.8+, standard library only)
import collections, datetime as dt, html, re, statistics, sys
MON = "JAN FEB MAR APR MAY JUN JUL AUG SEP OCT NOV DEC".split()
def day(s):
y, m, d = re.match(r"(\d{4})-([A-Za-z]{3}|\d{2})-(\d+)$", s.strip()).groups() # one 2025 row reads 2025-08-014
return dt.date(int(y), MON.index(m.upper()) + 1 if m.isalpha() else int(m), int(d))
def read(path):
raw = open(path, encoding="utf-8").read()
tabs = []
for t in re.findall(r"(?is)<table.*?</table>", raw):
rows = [[html.unescape(re.sub(r"<[^>]+>", "", c)).strip() for c in re.findall(r"(?is)<td[^>]*>(.*?)</td>", tr)]
for tr in re.findall(r"(?is)<tr[^>]*>(.*?)</tr>", t)]
tabs.append([r for r in rows if r and r[0].startswith("PZ-")])
upd = re.search(r"Most recent update:\s*([A-Za-z]+ \d+, \d{4}|\d{4}-\d\d-\d\d)", html.unescape(raw))
return tabs, upd.group(1) if upd else "?"
(o26, f26, l26), upd26 = read(sys.argv[1])
(o25, f25, l25), upd25 = read(sys.argv[2])
asof = dt.datetime.strptime(upd26, "%B %d, %Y").date()
rep26 = [day(r[3]) for r in o26 + f26 + l26]
rep25 = [day(r[3]) for r in o25 + f25 + l25]
print(f"2026 page (update {upd26}): {len(o26)} open, {len(f26)} fixed, {len(l26)} past deadline = {len(rep26)} reports, {min(rep26)} to {max(rep26)}")
cut = dt.date(2026, 8, 1)
for label, a, b in (("Jan 7-Jul 31", min(rep26), cut - dt.timedelta(1)), ("Aug 1-Nov 6", cut, max(rep26))):
n = sum(a <= d <= b for d in rep26)
print(f" {label}: {n} reports, {n / (((b - a).days + 1) / 7):.1f} a week")
print(f" Jun 1-Nov 6: {sum(dt.date(2026, 6, 1) <= d <= dt.date(2026, 11, 6) for d in rep26)} reports in 2026 against "
f"{sum(dt.date(2025, 6, 1) <= d <= dt.date(2025, 11, 6) for d in rep25)} in 2025")
print(f"2025 page (update {upd25}): {len(rep25)} reports, {min(rep25)} to {max(rep25)}")
def bands(days, label):
ok = lambda x: sum(v <= x for v in days)
print(f"{label}: n={len(days)} median={statistics.median(days):g} within30={ok(30)} within60={ok(60)} within90={ok(90)} over90={len(days) - ok(90)}")
d26 = [(r[1], int(r[5]), day(r[4]), r[6]) for r in f26]
bands([d for _, d, _, _ in d26], "fix time 2026")
bands([int(r[5]) for r in f25 if r[5].isdigit()], "fix time 2025")
print("over 90 days:", sorted((int(r[5]), r[1]) for r in f26 if int(r[5]) > 90))
print("rows where a stated fix time or deadline disagrees with the dates:",
sum((day(r[4]) - day(r[3])).days != int(r[5]) for r in f26) + sum((day(r[4]) - day(r[3])).days != 90 for r in o26))
by = collections.defaultdict(list)
for v, d, _, _ in d26:
by[v].append(d)
print(f"{'vendor':24s}{'fixed':>6}{'median':>8}{'<=60':>6}{'<=30':>6}")
rest = []
for v, ds in sorted(by.items(), key=lambda kv: -len(kv[1])):
if len(ds) >= 4:
print(f"{v:24s}{len(ds):>6}{statistics.median(ds):>8g}{sum(x <= 60 for x in ds):>6}{sum(x <= 30 for x in ds):>6}")
else:
rest += ds
print(f"{'all others':24s}{len(rest):>6}{statistics.median(rest):>8g}{sum(x <= 60 for x in rest):>6}{sum(x <= 30 for x in rest):>6}")
batch = collections.Counter((v, fx) for v, _, fx, _ in d26)
multi = {k: n for k, n in batch.items() if n >= 2}
big = sorted(batch.items(), key=lambda kv: -kv[1])[:4]
print(f"{len(d26)} fixes landed on {len(batch)} vendor-days; {sum(multi.values())} of them in {len(multi)} same-day batches")
print("largest batches:", [(f"{v} {fx}", n) for (v, fx), n in big])
span = [d for v, d, fx, _ in d26 if (v, fx) == big[0][0]]
print(f"the {big[0][0][0]} batch took {min(span)} to {max(span)} days from report to fix")
known = collections.Counter(v for v, _, _, p in d26 if p != "Unknown")
print(f"first known user device protected is a date for {sum(known.values())} of {len(d26)} fixes (2025 table: "
f"{sum(r[6] not in ('Unknown', 'N/A') for r in f25)} of {len(f25)}):", {v: f"{k} of {len(by[v])}" for v, k in known.items()})
print("reports by vendor:", dict(collections.Counter(r[1] for r in o26 + f26 + l26).most_common(4)))
bd = collections.Counter(rep26).most_common(1)[0]
print("busiest report day:", bd, {(r[1], r[2]) for r in o26 + f26 + l26 if day(r[3]) == bd[0]})
dl = collections.Counter((r[4], r[1], r[2]) for r in o26)
print("open reports by vendor:", dict(collections.Counter(r[1] for r in o26).most_common()))
print("earliest deadlines:", [(k, n) for k, n in sorted(dl.items(), key=lambda kv: day(kv[0][0]))[:2]], "| deadlines before 2027-01-01:", sum(day(r[4]) < dt.date(2027, 1, 1) for r in o26), "of", len(o26))
age = [(asof - day(r[3])).days for r in o26]
print(f"open reports older than 30 days: {sum(a > 30 for a in age)} of {len(o26)}; older than 60: {sum(a > 60 for a in age)}")
late = [(r[1], r[2], r[3], (asof - day(r[3])).days) for r in l26]
print("past deadline, unfixed:", late)
for label, d in (("Full 90", dt.date(2026, 11, 13)), ("Full 60", dt.date(2027, 2, 2)), ("Full 30", dt.date(2028, 1, 3))):
print(f"{label} starts {d} ({d:%A})")
for label, d, n in (("last Full 90 report", dt.date(2027, 2, 1), 90), ("first Full 60 report", dt.date(2027, 2, 2), 60),
("last Full 60 report", dt.date(2028, 1, 2), 60), ("first Full 30 report", dt.date(2028, 1, 3), 30)):
print(f"{label} {d} -> published {d + dt.timedelta(n)} ({d + dt.timedelta(n):%A})")
print(f"announcement to the first Full 30 publication: {(dt.date(2028, 2, 2) - dt.date(2026, 11, 13)).days} days")
On the November 10 update it prints:
2026 page (update November 10, 2026): 49 open, 61 fixed, 5 past deadline = 115 reports, 2026-01-07 to 2026-11-06
Jan 7-Jul 31: 43 reports, 1.5 a week
Aug 1-Nov 6: 72 reports, 5.1 a week
Jun 1-Nov 6: 84 reports in 2026 against 28 in 2025
2025 page (update 2026-03-17): 40 reports, 2025-06-18 to 2025-12-11
fix time 2026: n=61 median=46 within30=19 within60=37 within90=57 over90=4
fix time 2025: n=38 median=75 within30=3 within60=10 within90=25 over90=13
over 90 days: [(92, 'Samsung Mobile'), (94, 'Samsung Semiconductor'), (95, 'Google'), (101, 'Imagination')]
rows where a stated fix time or deadline disagrees with the dates: 0
vendor fixed median <=60 <=30
Apple 14 60 9 2
Samsung Mobile 9 76 1 0
Adobe 9 42 6 3
Google 6 43 4 3
Oracle 5 36 5 0
Linux 5 26 5 4
Imagination 4 85.5 0 0
FreeType 4 1 4 4
all others 5 20 3 3
61 fixes landed on 31 vendor-days; 41 of them in 11 same-day batches
largest batches: [('Apple 2026-10-26', 11), ('Samsung Mobile 2026-10-06', 5), ('Oracle 2026-09-15', 5), ('Adobe 2026-06-14', 4)]
the Apple batch took 46 to 62 days from report to fix
first known user device protected is a date for 11 of 61 fixes (2025 table: 19 of 39): {'Microsoft': '2 of 2', 'Oracle': '5 of 5', 'Apple': '1 of 14', 'Google': '3 of 6'}
reports by vendor: {'Apple': 44, 'Adobe': 16, 'Google': 15, 'Samsung Mobile': 12}
busiest report day: (datetime.date(2026, 8, 25), 14) {('Apple', 'Image Codecs')}
open reports by vendor: {'Apple': 30, 'Adobe': 7, 'Google': 4, 'Samsung Mobile': 3, 'Ittiam Systems': 2, 'Cisco': 2, 'AMD': 1}
earliest deadlines: [(('2026-NOV-23', 'Apple', 'Image Codecs'), 8), (('2026-NOV-25', 'Apple', 'Image Codecs'), 4)] | deadlines before 2027-01-01: 19 of 49
open reports older than 30 days: 22 of 49; older than 60: 12
past deadline, unfixed: [('Google', 'Android', '2026-JUN-24', 139), ('Google', 'Pixel', '2026-APR-29', 195), ('Google', 'Pixel', '2026-MAR-20', 235), ('Google', 'Pixel', '2026-MAR-17', 238), ('Google', 'Pixel', '2026-MAR-17', 238)]
Full 90 starts 2026-11-13 (Friday)
Full 60 starts 2027-02-02 (Tuesday)
Full 30 starts 2028-01-03 (Monday)
last Full 90 report 2027-02-01 -> published 2027-05-02 (Sunday)
first Full 60 report 2027-02-02 -> published 2027-04-03 (Saturday)
last Full 60 report 2028-01-02 -> published 2028-03-02 (Thursday)
first Full 30 report 2028-01-03 -> published 2028-02-02 (Wednesday)
announcement to the first Full 30 publication: 446 days
What we checked
- Project Zero: the policy post of November 13, the policy page, the FAQ, the 2026 and 2025 Reporting Transparency pages (all tables parsed) and the October 6 post
- Google: the application security vulnerability disclosure policy and the GTIG AI Threat Tracker report
- Other clocks: the Zero Day Initiative disclosure policy
- Coverage: SecurityWeek on the policy and The Register on the GTIG report
- Earlier on sxz.io: Apache mod_http2, PHP2Shell, the skb zerocopy bug and Brotli








No Comment! Be the first one.