Feature request: agent-native developer feedback integration without requiring Browser/Work

What feature would you like to see?

A first-party, narrow developer feedback integration that lets ChatGPT/Codex agents prepare and submit developer bug reports / feature requests to the appropriate OpenAI developer surface without requiring a general-purpose Browser/Computer Use/Work session.

The core use case is simple:

agent-assisted development
  -> integration/runtime finding
  -> user asks agent to report it upstream
  -> agent can prepare + submit through a scoped feedback action
  -> user explicitly approves the final mutation
  -> receipt / upstream URL returned

Today the route is uneven:

• Codex itself has a public GitHub issue tracker with an automation-friendly API.
• ChatGPT Apps SDK feedback is primarily routed through the OpenAI Developer Community web forum.
• In an ordinary ChatGPT/Codex agent session, there is no equivalent lightweight authenticated write surface for that forum.
• Therefore agent-assisted submission can require launching a much broader browser-driving Work/Codex session solely to navigate the forum UI and click New Topic.

That is disproportionate to the task and conflicts with least-capability / agent ergonomics. A small developer report should not require a runtime with substantially broader permissions, browser state, latency, and failure modes than the report itself needs.

Why this matters for agent-first development

OpenAI is increasingly encouraging agentic development workflows, but the feedback loop still has a manual/web-only seam.

For plugin/app/skill/MCP development, an agent can often:

1. reproduce a bug;
2. inspect logs and runtime behavior;
3. compare documentation;
4. prepare a minimized reproduction;
5. find related upstream issues;

…but then cannot submit the resulting report through a narrow first-party action.

That forces an unnecessary escalation:

small finding
  -> need upstream feedback
  -> no scoped write action
  -> launch Browser / Computer Use / Work
  -> navigate authenticated forum UI
  -> submit post

The feedback path itself becomes heavier than the debugging task.

Requested behavior

Any one of these would solve the core problem:

1. First-party Developer Feedback plugin/app for ChatGPT and Codex.
2. A documented, scoped Developer Community posting API suitable for agent use.
3. A Submit developer feedback action in Codex/ChatGPT that routes to the appropriate surface (Codex GitHub tracker, Apps SDK Community, etc.).
4. A unified public developer issue tracker for cross-surface Apps/Plugins/Skills/Codex integration problems.

The action should be narrow and auditable:

prepare draft
show exact target + title + body
require explicit user approval
submit
return receipt / URL / issue ID

No general browser permissions should be required for this path.

Existing first-party precedent

OpenAI already ships a first-party ChatGPT Admin plugin with Interactive/Read/Write capabilities for workspace owners/admins, and supports workspace-scoped Admin APIs/keys for eligible managed workspaces. That demonstrates the product pattern of exposing narrow operational control surfaces to agents instead of forcing UI automation.

A developer-feedback integration would apply the same principle to the developer loop.

Public plugin card:
https://chatgpt.com/plugins/plugin_connector_1p_e4d796f7afc48191bf6af2220a55fdd6

Admin key docs:
https://help.openai.com/en/articles/20001407-managing-admin-keys-in-admin-console

Related observability context

This request is separate from, but complementary to, existing Codex observability issues such as:

• #35869 — plugin Skill injection / missing telemetry event
• #41760 — first-class SkillInvocation events
• #39166 — skill-only plugin invocation differences across Codex surfaces

Those issues address knowing what the agent/runtime did. This request addresses being able to report what was found upstream through a proportionate agent-native channel.

Reproducible research context

This came up while testing a ChatGPT memory-provider integration where clean attribution requires provider isolation and routing telemetry. The broader research/evidence packet is public here:

https://github.com/TeaShaman-cyber/theseus-memory-provider-lab/issues/7

That research exposed two distinct developer gaps:

1. capability isolation / routing observability;
2. an agent-native path to submit the resulting feedback without escalating to browser automation.

Acceptance sketch

From a normal ChatGPT or Codex development session, a user can say:

File this as developer feedback to the appropriate OpenAI surface.

The agent prepares the exact submission, shows the destination and content, requires explicit approval, submits through a scoped first-party action, and returns a durable receipt or upstream URL.

No Browser/Computer Use/Work session is required unless the user explicitly chooses that route.

No repository file, test, or implementation entry point is identified in the issue. Start with the requested ChatGPT/Codex feedback surfaces and the acceptance sketch, then determine the appropriate scoped action, approval flow, and receipt behavior; done means an approved report can reach the appropriate upstream surface without Browser, Computer Use, or Work.