November 17, 2026
Bug bounty is in a rough place right now. Security researchers and program managers are both unhappy. Researchers are dealing with reduced payouts and no reward, but fixed anyway programs. Annoyed by slower response times. Some are unhappy with the trend to AI-only workflows.
On the flip side, we have the program managers. Programs are overwhelmed with how many reports they're getting. Budgeted spend is being used up quickly. Legitimate bugs are getting harder to distinguish from spam.
If both sides aren't happy, why don't we change it?
I’ve spent the last five years on both sides of bug bounties: finding bugs and managing programs. These experiences have given me plenty of opinions about what works, what doesn’t, and what needs to change for this to work for both parties going forward. This post contains what I think needs to change about bug bounties. Some are radical, but we won't progress without big changes.
Low signal and high report volume are killing the current bug bounty model. AI slop is a major driver. A PoC can even look plausible and still be a lie. The text can be incredibly long and still add no real value. Worst of all, slop reports put the burden on the triager while costing the reporter little.
In practice, this leads to major problems on bug bounty platforms:
The reporter bears the burden of proof to demonstrate a valid vulnerability; it's not the triager's job to disprove it. An increase in report volume and decline in report quality are consuming engineering hours. My suggestion: be ruthless about closing low-quality reports.
Find the first legitimate reason to close the report. If the report contains technical inaccuracies in the code, it's not worth going any further. If the proof of concept doesn't work immediately, don't spend an hour debugging it. If the threat model is invalid, close the report. If the text is impossible to read, ask the reporter to give you a one-paragraph summary of the bug in another submission. To make this tenable for hunters, always explain the reason for closure and allow researchers to resubmit if they believe you made a mistake.
Using this strategy, I've never regretted closing a report. My gut has been right 99% of the time, and in the remaining 1%, researchers can resubmit. This clears queues faster, gets legitimate vulnerabilities triaged and paid sooner, and shifts the time burden back to reporters.
Programs and platforms need to ban researchers more quickly for repeatedly abusing the reporting process. In my experience, much of the spam and unnecessary effort comes from the same accounts. I've even seen a researcher hit the four-report submission limit, then request an increase to submit 12 more "critical" vulnerabilities, despite their existing reports being spam. Researchers who repeatedly submit low-quality reports, misleading PoCs, or act in bad faith should platform face bans.
Many Web3 bug bounty platforms, such as Immunefi and Cantina, put many items behind a paid gate. Whether you like how they've implemented this or not, it has a major feature: it prevents spam. It stops reports you don't care about from being reported. It keeps the submission workflow manageable while still letting real bugs through. Eventually, if people are sending pure spam, they'll lose money and stop submitting bugs.
There are an infinite number of knobs to turn here. If the whitehat has a high rating/accuracy, you could skip the fee. If the whitehat has a terrible rating, then add a fee. If the bug is valid/duplicate, the whitehat gets a refund. There is a lot of thinking to do on how we gate submissions with both money and reputation. Regardless, I see paid submissions becoming increasingly popular across these platforms as they try to reclaim the high signal of prior years.
The threat model defines what a program wants to pay out and what it cares about. For example, account takeovers are worth $20K. There are typically nuances on the severity here. An account takeover that requires two clicks is worth less than zero clicks. Although it makes intuitive sense, the bug bounty program doesn't state this rule explicitly. As a result, many bounty hunters focus on the maximum amount for the tier without considering these complexities. When their unrealistic expectations aren't met, they end up angry about the payout; we've all been there.
The typical response is to write more rules: payout amounts, severity requirements, in-scope assets, conditions that drop severity, and so on. But no number of rules can cover every possible scenario, and no formula perfectly measures impact and likelihood (see the longstanding criticism of CVSS).
Instead of writing lots of rules, lean towards statements about what you care about; make everything impact-based. Immunefi has primacy of impact programs that focus severity on impact rather than defined scope rules. When a report comes in, security engineers and triagers can focus on actual impact and likelihood instead of following a strict set of rules. The benefit is a more realistic risk assessment. Two vulnerabilities with the same technical classification can have wildly different consequences depending on the affected system, exploit requirements, and potential damage. A rigid severity table might treat both the same, while subjective evaluation lets programs reward the risk that actually matters. What makes us good at this is being human. Be subjective.
Subjectivity cuts both ways. Sometimes, you get paid more than what you expect for a bug. Often times, you get less. Researchers would need to accept some unpredictability in payouts, even for seemingly similar vulnerabilities. In return, programs must justify their decisions and earn researchers' trust. Like many others, I have been rugged my fair share of times, and get how scary this change sounds.
Allowing for subjectivity does have a problem, though: it requires you to trust the program. Otherwise, a program could easily say "little impact" to every reporter and pay out nothing. So, how do we make people trust programs? Transparency!
General program metrics are useful. On HackerOne, metrics like severity distribution, average payout per severity level, bugs paid out per month, and more are strong indicators of a healthy bug bounty program. Immunefi signals provide similar information. This is probably the most useful transparency mechanism for getting whitehats to trust the programs. On the flip side, with bad stats, hunters will know to stay away from those programs.
Meta has an excellent bug bounty program. How do we know this? Researchers regularly publish both their vulnerabilities and the rewards they receive from Meta. For instance, Youssef Sammouda, one of Meta's most prolific security researchers, has earned hundreds of thousands of dollars in bounties, including $187,250 for six vulnerabilities. His personal blog alone contains over 80 Meta-specific vulnerability write-ups, covering everything from information disclosure and account takeovers to remote code execution. Public disclosures like these build trust in the program and give researchers a concrete sense of what their work might be worth.
Both individual writeups and metrics help us trust the bug bounty program more. Both give researchers a positive signal that the program is worth their time. The more transparent a program is, the better a researcher's payout expectations are. If it's good, engineers will flock to it. If it's bad, then the program will get little coverage from bug bounty hunters.
The bug bounty program is trying to mitigate risk. The goal of the bug bounty hunter is to prove as much risk as possible to maximize their payout.
Since a critical bug often pays out 10x a high, trying to escalate vulnerabilities is a good strategy. This could mean chaining more bugs together, or finding new ways to exploit the issue. A good example of this chaining is from Youseff on Meta, where three separate bugs lead to an account takeover. With LLM's, this has changed significantly. The current trend is to report as many bugs as possible. This has flipped the bug bounty impact model on its head.
What happens when a bug is reported as low without explaining its real impact? Or if it's part of a chain of three bugs? Typically, medium or low severity bugs sit for weeks, months, or even years before anyone fixes them. Once a new report shows the issue's real impact, the bug becomes a priority and gets fixed immediately. I've even seen reports closed as invalid be marked as duplicates, where the new report worked around the original closure reason. Unfortunately, the security researcher who found the impact isn't paid out because of the first reported-only paid rule, so it's closed as a duplicate. This needs to change.
Being first is no longer enough: you need to show impact with your report. The company benefits from knowing the issue's true severity. The secondary reporter is the one who gave them the real value, not the original reporter. So, bug bounties should reflect this.
First, let's flip the standard first reported-only paid rule. Reward the report that generates the most impact. If a report was closed as invalid but the second report gets through, I'd consider it the same scenario. There's an easy way to define this: if the reporter increased the severity by one level, such as invalid to valid, or medium to high, they deserve the payout. This applies regardless of submission order. If the severity is the same, then pay out the first as before. This will incentivize researchers to maximize a vulnerability's impact before reporting it.
Second, the made-you-fix rule. If a program pays, or internally knows about a low-severity issue, but never fixes the bug, it's still a risk. If somebody takes the same bug and increases the severity level, or uses it in a chain that causes the program to fix the issue, that deserves a reward. A previously unknown risk has been mitigated by the reporter. In this case, both parties win: one mitigated a bad risk while the other gets compensated for the discovery. My suggestion would be new bounty - old bounty. If a reporter moves a low to a critical, then the payout would be substantial. Don't reward the bug spammer who found zero impact. Don't reward the LLM tooling that "found" the bug without any context of its true impact.
Several bug bounty programs have removed medium and low severity bugs from scope, such as Chrome and Coinbase. Since many bug bounty hunters live off medium and low severity bugs, this is pretty scary. Another concern for whitehats is that programs can just arbitrarily drop a bug from critical to medium, and thus not pay out. All in all, this change is awful for full-time bounty hunters.
From the program's perspective, the decision makes sense: teams are overwhelmed and need to focus on the highest-impact findings. Additionally, since most LLM scanners can find lower-severity bugs, teams can find these internally. This saves on both paid bounty costs and engineering resources. I think this is an acceptable temporary measure during the current LLM-driven bug bounty gold rush.
Eventually, I expect things to even back out again; the gold rush ends, and triage processes improve. When that happens, medium and low severity vulnerabilities should absolutely be rewarded again. Personally, I wouldn't hunt on a program that doesn't reward medium severity findings. It's a bad signal, and these programs will drive away researchers. Others may feel differently, but I suspect the market will eventually push programs toward broader coverage again.
Everyone's goal should be to make the triaging process manageable for programs while keeping bug bounty a legitimate career. If programs don't have the money to pay out or the bandwidth to triage, whitehats simply don't get paid. If whitehats can't trust programs to pay out for bugs, then they won't find bugs on projects. From leaning into subjectivity to closing reports faster to restructuring who gets paid, there are a lot of knobs to turn for both the whitehats and program managers. Ultimately, bug bounties only work when they're worthwhile for both researchers and companies.
Thanks for reading the post! I hope some of these changes benefit the industry, both for program managers and whitehats. Cheers from Maxwell "ꓘ" Dulin.