Feature Request: Verified internal evidence links for bug and feature reports

ChatGPT Feature requests
1

Feature Request

ChatGPT and the OpenAI Developer Community
would benefit from a shared,
verified evidence-link system.

Users frequently create
bug reports and feature requests
based on material
that already exists inside ChatGPT.

Examples include:

  • screenshots
  • reference images
  • generated images
  • comparison sheets
  • PDFs
  • documents
  • conversation excerpts
  • test evidence
  • diagnostic files

At the moment,
this material often has to be
uploaded again manually
to the Developer Community.

External links may also be restricted
or rejected in some posting situations.

Images may require
separate moderation.

This creates unnecessary duplication
between two parts
of the same broader ecosystem.

Suggested concept

ChatGPT could provide
an internal evidence library.

A user could select material
inside ChatGPT and choose:

“Create verified evidence link”

The system would then create
a stable OpenAI-hosted reference
that could be inserted
into a Developer Community report.

Conceptually:

ChatGPT file / image / evidence
→ internal moderation / validation
→ stable evidence ID
→ verified OpenAI-hosted link
→ Developer Community post

Example

A user documents
an image-generation problem
inside ChatGPT.

The conversation already contains:

  • reference image
  • generated result
  • corrective reference
  • failed corrected result

Instead of uploading
all four files again
to the forum,
the user could create:

Evidence Set:
Reference Adherence Test 01

The forum post could then contain:

OpenAI Evidence Set:
RA-2026-001

Opening that reference
would show only the material
the user explicitly chose to share.

Evidence sets

The system could allow
multiple files to be grouped
into one evidence package.

For example:

Evidence Set:
Narrative Lighting Test

Contains:

  • Case 1 original
  • Case 1 treatment
  • Case 2 original
  • Case 2 treatment
  • Case 3 original
  • Case 3 treatment

This would be especially useful
for technical comparisons.

Privacy and control

The user should decide
exactly what becomes shareable.

Creating an evidence link
must not expose:

  • the whole conversation
  • unrelated files
  • private messages
  • hidden context
  • other project material

Only explicitly selected items
should be included.

The user should also be able to:

  • revoke the link
  • replace an evidence file
  • add a new version
  • see where the link is used
  • set public / private access
  • set an expiration date

Verified internal links

Because the material
would remain inside
OpenAI-controlled infrastructure,
the link could be treated differently
from an arbitrary external URL.

The Developer Community
could recognize it as:

Verified OpenAI evidence

rather than:

unknown external link

This could reduce:

  • spam risk
  • duplicated uploads
  • broken links
  • repeated moderation work
  • user friction

Integration with ChatGPT

Inside a conversation,
the user could select:

  • one image
  • several images
  • a PDF
  • generated output
  • selected messages
  • a comparison sheet

and choose:

Share as evidence

The resulting reference
could then be copied directly
into a bug report
or feature request.

Why this matters

Technical reports become much stronger
when supporting evidence
is directly available.

But users should not have to:

download
→ rename
→ re-upload
→ re-explain
→ re-moderate

the same material repeatedly.

The evidence already exists.

The missing piece
is a safe bridge
between the working environment
and the reporting environment.

Core principle

Create evidence once.

Reference it safely
where it is needed.

Acceptance criteria

  1. Users can create
    stable evidence links
    from ChatGPT-hosted material.

  2. Only explicitly selected content
    becomes accessible.

  3. Evidence links are recognized
    as OpenAI-hosted references.

  4. Multiple files can be grouped
    into one evidence set.

  5. Evidence can be versioned
    without changing
    the underlying report.

  6. Users can revoke access.

  7. Developer Community posts
    can embed or reference
    verified evidence sets.

  8. The system reduces
    repeated uploading
    and duplicate moderation.

  9. Internal evidence links
    preserve source provenance.

  10. Private conversation content
    remains private
    unless explicitly selected.

2

Hi!

That’s a nice suggestion, but there is one problem:

Many users do not follow suggested templates. They simply want to share something they found while working with ChatGPT.

Bug reports are a good example. When creating a topic in one of the bug categories, we specifically load a template into the composer asking for details such as:

  • Which product surface are you using?
  • Which version are you on?
  • Etc.

You may have noticed that only a few users actually take the additional two minutes to fill in this helpful information.

Given that, how do you think we could make this work?

3

Hi VeitB,

that is exactly the problem
I would try to avoid.

I would not make the evidence system
another form the user has to complete.

Ideally, most of the report
would already be prefilled
from the active ChatGPT workflow.

For example, ChatGPT could already know
or collect where available:

  • product surface
  • browser / app
  • operating system
  • model / feature involved
  • relevant screenshots
  • uploaded files
  • generated outputs
  • selected conversation excerpts
  • approximate reproduction sequence

The user could then choose:

“Create bug report from current task”

ChatGPT would prepare:

  1. a short issue description
  2. available environment information
  3. reproduction steps
  4. selected evidence
  5. a verified evidence set

The user would only review
what is going to be shared
and fill in genuinely missing details.

If one important field is missing,
the assistant could ask directly:

“Which browser version are you using?”

instead of presenting
a mostly empty template.

So the goal would be:

less manual form filling,
more automatic capture
from the workflow that already exists.

In other words,
the evidence bridge should reduce
the reporting burden,
not add another reporting step.

That is also why I think
the ChatGPT side matters:

the system has much more context
about how the problem occurred
than the forum composer has.

4

At this point, the app could create a bundle of debugging information and send it straight to support for investigation. The ChatGPT app already does this with the /feedback command. So, it’s a reasonably good idea. Sending the info to support is the better option, IMO.

In the Developer Community Forum, we support people building with OpenAI, and developers most often know quite well what is needed for a proper report and how to reproduce the issue they are having.