I am experiencing a consistently reproducible issue with a custom MCP app in ChatGPT Developer Mode.

The issue is that the custom MCP app and its tools are available to the model during the first turn of a conversation, but on the immediately following user turn the entire MCP tool namespace is no longer available to the model.

This happens even if no MCP tool is actually invoked during the first turn.

Environment

  • ChatGPT web
  • Developer Mode enabled
  • Custom remote MCP server
  • MCP app uses read/search/fetch-type actions only
  • OAuth authentication
  • The MCP server and its tools are successfully detected during the initial tool scan
  • The app can be selected and used successfully in a new conversation

I have reproduced the issue across multiple ChatGPT models, so it does not appear to be specific to one particular model.

Minimal reproduction steps

  1. Start a new ChatGPT conversation.
  2. Select/attach my custom MCP app from the tools/apps menu.
  3. In the first message, ask ChatGPT only to load or inspect the available MCP tools.
  4. ChatGPT successfully sees the custom MCP namespace and all expected MCP tools.
  5. Do not invoke any MCP tool.
  6. Send a second user message asking ChatGPT to use one of those MCP tools.
  7. On the second turn, the custom MCP namespace is no longer present in the model runtime, so ChatGPT is physically unable to invoke the tool.

Actual behavior

On turn 1, the custom MCP tools are available, for example:

  • legislation lookup
  • legislation search
  • other MCP read/search tools

On turn 2, the entire custom MCP namespace disappears from the set of callable tools available to the model.

This is not a normal MCP tool-call failure. The model does not call the MCP server and receive an HTTP, OAuth, schema, or MCP error.

Instead, the tool itself is no longer exposed to the model at all.

In other words, the failure happens before a request could reach our MCP server.

Expected behavior

A custom MCP app selected for a conversation should remain available across subsequent turns of that conversation, unless the user explicitly disables or removes it.

The MCP tool definitions should therefore continue to be exposed to the model on turn 2, turn 3, etc.

This also appears consistent with the current OpenAI documentation, which describes selecting an app for a chat/conversation and then testing it using different prompts and use cases in that conversation.

Important diagnostic information

I have performed several tests to isolate the cause.

1. The issue does not depend on MCP response size.

Originally I suspected that large MCP results could cause context compaction or another runtime issue.

However, I can reproduce the problem without invoking any MCP tool at all on the first turn.

Therefore there is no MCP response, large or small, before the tool namespace disappears.

2. The issue is reproducible across multiple models.

I reproduced the same behavior using different ChatGPT models, including GPT-5.5.

This therefore does not appear to be specific to one model.

3. The MCP server works correctly when the tool is available.

When ChatGPT exposes the MCP tools, calls reach our server and complete successfully.

The problem occurs only on the next conversation turn, when the MCP tool namespace is no longer exposed to the model.

4. The failing turn does not reach our MCP server.

Our server does not receive the expected MCP tool invocation on the failing second turn.

This is consistent with the fact that the tool is absent from the model’s available tool registry before invocation.

5. This does not appear to be caused by a tool schema change.

The MCP schema is unchanged between turn 1 and turn 2.

The tools are successfully discovered initially.

If this were a frozen-snapshot/schema mismatch, I would expect the existing tool call to fail. Instead, the entire MCP namespace disappears from the model runtime.

6. OAuth expiration is unlikely to explain the behavior.

The transition from the first working turn to the second failing turn occurs within seconds.

Additionally, the symptom is not an authentication failure when invoking the MCP server. The tool definition itself disappears before any authenticated request can be attempted.

Why this appears to be a ChatGPT app/tool lifecycle issue

The observable sequence is:

Custom MCP server
        ↓
App successfully configured and scanned
        ↓
App selected in ChatGPT conversation
        ↓
Turn 1: MCP tool namespace available
        ↓
Next conversation turn
        ↓
MCP tool namespace no longer present in model runtime
        ↓
No request can be made to the MCP server

This suggests that the custom app attachment or MCP tool manifest is not being persisted when ChatGPT constructs the runtime/tool registry for the subsequent conversation turn.

Additional reproduction variant

The same problem can also be demonstrated with an actual tool invocation:

  1. Start a new conversation.
  2. Select the custom MCP app.
  3. Ask ChatGPT to invoke an MCP read tool.
  4. The invocation succeeds and the MCP server returns a valid result.
  5. Send another message asking ChatGPT to invoke another tool from the same MCP app.
  6. The custom MCP namespace is no longer available to the model.

However, the stronger reproduction is the first one described above, because the issue occurs even when no MCP call whatsoever is made on the first turn.

Current OpenAI documentation

The current documentation for Developer Mode and MCP apps states that users should:

  • open a new chat and select the draft app;
  • try different prompts and use cases for the app;
  • use tools exposed by the app.

It also states that app permissions apply to ChatGPT conversations.

Therefore, I understand the expected behavior to be that a custom MCP app selected for a conversation remains available across multiple turns, rather than only during the first turn.

Request

Could you please confirm whether this is a known issue with custom MCP apps / Developer Mode?

In particular, could you investigate whether the custom MCP app attachment or its tool manifest is being dropped when ChatGPT creates the runtime for the next conversation turn?

If useful, I can provide:

  • MCP endpoint details;
  • OAuth metadata;
  • MCP tool schemas;
  • screenshots/video showing the reproduction;
  • timestamps of successful and failing attempts;
  • server logs showing that the failing second turn never reaches the MCP server;
  • HAR/browser logs;
  • the custom app ID / connector ID.

I would also be happy to test any workaround or additional diagnostic steps you recommend.

Thank you.