esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

AI guardrails & red teaming / Advanced / 03.10

Responsible disclosure

You found a flaw in someone else's AI product. Here is how to tell them safely, what to put in the report, and what never to do.

14 min readFree

You found something. Now what?

The last lesson, Writing the report, ended with a promise: next, responsible disclosure, telling a company about a flaw. Here it is.

Picture this. You are using a chatbot on a shop's website, and you notice it behaves in a way its makers surely did not plan. Maybe it shows something it should hide. Your stomach drops a little. What do you do next? Post it online? Tell a friend? Poke around more to see how bad it is?

One rule comes before everything else, so here it is early: test only systems you own or have written permission to test. Finding a flaw by accident is one thing. Going looking in someone else's product without permission is another, and it can have legal consequences.

Key words

Vulnerability
A flaw in software that can be abused to cause behaviour nobody intended.
Disclosure
Telling other people about a vulnerability. The question is who you tell, and when.
Coordinated disclosure
You report the flaw to the people who can fix it, and everyone agrees on a fair time before details go public.
Vendor
The company or team that makes and looks after the product.
security.txt
A small text file a website can publish to say where to send security reports.
Bug bounty
A programme where a company pays people, or at least thanks them, for reporting flaws the right way.
Scope
The list of things a programme says you may test, and the things it says you may not.

By the end you will know why the old name changed, where to find a company's reporting address, what a good report holds, what to expect on timing, and what to avoid. You will also run a short program that checks a security.txt file.

What disclosure means

The Wikipedia page on vulnerability disclosure describes it as a process where independent researchers discover flaws in software that can be abused to cause unintended behaviour. How the findings are shared with others is, in its words, "the subject of much debate".

So there is more than one way to share. The page names three.

  • Coordinated disclosure

    Researchers report to the vendor, or to a go-between who passes it on. Details go public later, once a fix is ready or a fair time has passed.

  • Full disclosure

    Details are published as early as possible, for everyone. The page says the aim is that potential victims are as knowledgeable as those who attack them.

  • Non disclosure

    Details are kept private, or shared only under a signed promise of secrecy. The page says common supporters include commercial exploit sellers and researchers who plan to use the flaw.

The page says many prominent researchers favour full disclosure while most vendors prefer coordinated disclosure. This course teaches the coordinated way: it is the calmest for you, the company and the people who use the product.

Why does waiting help? Think of a neighbour whose front door lock is broken. If you shout it down the street, burglars hear too. If you knock and tell them quietly, they can fix it. The page makes the same point: many people argue that end-users cannot use details of a flaw without guidance or a fix from the vendor, so sharing too early mostly helps the wrong people.

Why the name changed

You will still hear the old name. The page says coordinated vulnerability disclosure was "previously known as responsible disclosure". Either name is understood. What matters is the habit: report quietly, give time to fix, share later.

Permission and the law

Here is the uncomfortable part. Finding flaws looks a lot like attacking. The Wikipedia page on bug bounty programs says vulnerability discovery is similar in many respects to cyberattack, and that even well-meaning people can break criminal laws written for cybercriminals. It also says it is common for people who find flaws to receive legal threats after disclosing them.

Rules differ from country to country, and none of this lesson is legal advice. But our sources give you a clear way to lower the risk: stay inside the rules a company has published.

  • Programmes grant permission

    The bug bounty page says these programmes "grant permission for unaffiliated individuals" to find and report vulnerabilities. The permission is the programme's written rules.

  • Outside scope is risky

    The same page says that people who look outside a programme's scope "might find themselves facing legal threats under cybercrime laws".

  • Safe harbor has limits

    Safe harbor is a promise not to take action against people who follow the rules. The page says nearly all programmes promise it for reports that follow their policy, but if the flaw does not fall under an existing programme, the company could report it as an illegal cyberattack.

For AI products this means one thing. Before you test, find the company's written rules. Look for a disclosure policy or a bug bounty page. If you cannot find one, do not test. Ask, in writing, first.

Quick check

A company has no published rules about testing its chatbot. What is the safest move?

Where to send the report

You have permission, or you stumbled on something in plain sight and want to say so. Now: who gets the message?

RFC 9116 starts from this exact problem. It is a document from the Internet Engineering Task Force, the group that writes internet rules. Its abstract says: when researchers find flaws, "proper reporting channels are often lacking. As a result, vulnerabilities may be left unreported."

The RFC's answer is a small file called security.txt. Its abstract calls it a machine-parsable format to help organizations describe their vulnerability disclosure practices. In plain words: a website puts a short text file in a known place that says, here is how to tell us about a flaw.

  1. 1

    Look for the file

    For a website, the RFC says it must be under the "/.well-known/" path, for example https://example.com/.well-known/security.txt. For older setups it may sit at the top level, but if both exist, the ".well-known" one is the one to use.

  2. 2

    Read it all

    Check the Contact line, the Policy link and the Expires date before you send anything.

  3. 3

    Read the policy

    The Policy field points to the company's disclosure rules. Read them. They say what is in scope and what is not.

  4. 4

    Use the contact it gives

    Send your report there, and nowhere else.

The fields of security.txt

The file is made of simple lines, each one a field name, a colon and a value. Here are the fields this lesson cares about, as RFC 9116 defines them.

  • Contact (required)

    How to report: an email address, a phone number or a web page. The RFC says this field must always be present. Web addresses must begin with https://, and an email must be written as a mailto: link.

  • Expires (required)

    The date and time after which the file is stale and should not be used. It must be present and must not appear twice. The RFC recommends a date less than a year into the future.

  • Policy (optional)

    A link to where the company's disclosure policy lives. It helps you understand how they handle reports.

Why does Expires exist? The RFC's section on stale information explains: if the details are old, reports may never arrive or may go to the wrong person, which exposes the flaw to others. It even says not having a file may be preferable to having stale information in it.

Bug bounty and disclosure programmes

Some companies go further than a text file. They run a programme. The bug bounty page defines it: individuals can receive recognition and compensation for reporting bugs, especially security flaws. It then adds a useful name: if no money is offered, it is called a vulnerability disclosure program.

So there are two flavours. A bug bounty pays. A vulnerability disclosure programme only accepts reports and thanks you. Both give you written rules, and written rules are what make your testing allowed.

  • Scope

    What may you test, and what is off limits? Stay inside the lines.

  • Rules

    What methods are allowed? Does the programme promise safe harbor for reports that follow them?

  • Reward

    Is there money, a thank-you, or nothing? The page says reward size varies with the company, the difficulty and the severity.

  • Secrecy terms

    Some programmes ask you to sign a promise of secrecy. The page says this has been criticised on ethical grounds. Read before you sign.

What goes in a good report

Our sources do not give a template for the body of a report, so this part is plain common sense, built on the reasons reports get rejected. A good report makes it easy for a busy person to say yes.

  1. 1

    Say where

    Name the product and the exact place. If it is in scope, say which programme rule covers it.

  2. 2

    Say what happened

    Describe what you saw in plain words, in a few short sentences.

  3. 3

    Show how to see it again

    List the small steps that reproduce it, so the team can check for themselves. Use harmless test input only.

  4. 4

    Say why it matters

    Explain the harm in one or two lines: who could be hurt or what could leak.

  5. 5

    Keep proof small

    A short note or a trimmed screenshot is enough. Hide any real person's data before you attach it.

  6. 6

    Offer to help

    Say you will answer questions, and give them a way to reach you.

How long should you wait?

Coordinated disclosure means agreeing on a fair time to fix the flaw before details go public. How long is fair? The vulnerability disclosure page says it depends. The period "may vary between a few days and several months", depending on the potential impact, the time needed for a fix or workaround, and other factors.

Some groups use fixed deadlines so a vendor cannot delay forever. These are those groups' own policies, not laws, and a company's own policy may say something else. The page names two.

  • 90 days

    Google Project Zero has a 90-day deadline that starts when it tells the vendor. Details go public after 90 days, or sooner if the vendor releases a fix.

  • 120 days

    ZDI has a 120-day deadline that starts after it receives a response from the vendor.

Quick check

Which is the best description of coordinated disclosure?

What is different with AI products

Our three sources are about software flaws in general. None of them is about AI products, and we fetched no vendor page that says which AI problems a company accepts. So nothing below is a rule from a source. It is a careful way to think, and you must check each company's own page.

Start by sorting what you found into one of two piles.

  • A model behaviour issue

    The model says or does something it should not, for example a rude answer, a wrong answer, or a safety filter that slipped. This is about what the model produced.

  • A security flaw

    Someone could reach data or features they should not. Examples: a chat that shows another customer's details, a tool the model can call that has too much power, or a key left in public. This is about access and data.

  • Not sure

    Treat it like a security flaw until the programme's page says otherwise. Report privately, and do not make it worse by digging.

Why the sorting matters: programmes differ. One programme's scope may include model behaviour, another's may not, and some send behaviour reports to a different form. That is why you read the scope first. If the page does not say, ask the contact before you send details.

Tip

A fake, made-up example: a stand-in chatbot for an imaginary shop called MangoChat says its secret word is "kiwi" to anyone who asks nicely. Report that the secret leaks. Do not publish a clever trick for getting it, and do not post the leaked word.

What not to do

The sources give hints, and common sense gives the rest. Keep this list near you whenever you find something.

  • Do not hoard data

    If you see a real person's details, stop. Do not copy, save or share them. Note where you saw them and report it.

  • Do not go further than you need

    You only need enough to show the flaw is real. Exploring after that risks harm and breaks most programme rules.

  • Do not post harmful output

    Do not put screenshots of harmful model output, or the exact words that caused it, on social media. Describe it in the private report.

  • Do not demand money

    The disclosure page notes that some people see reporting with an expectation of payment as extortion. Ask about rewards only through a programme that offers them.

  • Do not leave scope

    Stay inside what the programme allows. Out-of-scope work is where legal threats come from.

Try it: check a security.txt file

Time to practise on safe, made-up data. The program below reads three invented security.txt files for three invented sites, all ending in ".example". For each one it checks the two required fields, Contact and Expires, then checks whether the date has passed.

It uses a fixed "today" of 16 November 2026, so you get the same answer every time. It uses only the Python standard library. No network is touched: the files are just text inside the code.

Python
from datetime import datetime, timezone

TODAY = datetime(2026, 11, 16, tzinfo=timezone.utc)

files = {
    "chatshop.example": """# Our security address
Contact: mailto:security@chatshop.example
Policy: https://chatshop.example/disclosure-policy
Expires: 2027-03-31T18:37:07z
""",
    "fruitbot.example": """Contact: https://fruitbot.example/report
Policy: https://fruitbot.example/rules
Expires: 2025-12-31T18:37:07z
""",
    "mangochat.example": """# no contact, no expiry
Policy: https://mangochat.example/rules
""",
}

def parse(text):
    fields = {}
    for line in text.splitlines():
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        name, _, value = line.partition(":")
        fields.setdefault(name.strip(), []).append(value.strip())
    return fields

def check(text):
    fields = parse(text)
    notes = []
    if "Contact" not in fields:
        notes.append("MISSING Contact (required)")
    else:
        notes.append("Contact ok: " + fields["Contact"][0])
    if "Expires" not in fields:
        notes.append("MISSING Expires (required)")
    elif len(fields["Expires"]) > 1:
        notes.append("Expires appears more than once (not allowed)")
    else:
        when = datetime.fromisoformat(fields["Expires"][0].upper().replace("Z", "+00:00"))
        days = (when - TODAY).days
        if days < 0:
            notes.append(f"STALE: expired {-days} days ago, do not rely on it")
        elif days > 365:
            notes.append(f"Expires in {days} days (more than a year, not recommended)")
        else:
            notes.append(f"Expires ok: {days} days left")
    notes.append("Policy link found" if "Policy" in fields else "no Policy field (optional)")
    return notes

for site, text in files.items():
    print(site)
    for note in check(text):
        print("  -", note)

Output

chatshop.example
  - Contact ok: mailto:security@chatshop.example
  - Expires ok: 135 days left
  - Policy link found
fruitbot.example
  - Contact ok: https://fruitbot.example/report
  - STALE: expired 320 days ago, do not rely on it
  - Policy link found
mangochat.example
  - MISSING Contact (required)
  - MISSING Expires (required)
  - Policy link found

Read the output. chatshop.example has a Contact and an Expires date 135 days away, so it is fine. fruitbot.example has a Contact, but its Expires date passed 320 days ago, so the RFC says do not use it. mangochat.example has neither required field, so you would have no address to send a report to. The files are made up, so do not look for them.

Wrapping up

  • Before

    Read the rules and scope. If there are none, ask in writing.

  • During

    Stop at proof. Do not hoard data. Report privately.

  • After

    Wait for a reply and respect the agreed time. Only then talk about it in public, if the company agrees.

Quick check

A security.txt file has an Expires date from last year. What should you do?

Next: the standards and frameworks the industry uses.

Sources

How is this lesson?

Last updated on 16 November 2026

Learn with me

Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.