Quick answer: Pasting a key into a prompt can send it to the model and conversation infrastructure handling that prompt. Storage, sharing, training and retention depend on the client, deployment and settings. Avoid unnecessary prompt disclosure; if a live key has been exposed, assess and invalidate it at the provider as appropriate. Retrieving it through a tool is not a guarantee that it stays outside model context.
Follow the actual data path
A pasted secret becomes part of the input you give the application. What happens next depends on its design:
- Model processing: A hosted client may send it to a model provider. A fully local deployment has a different path, but may still persist or export it.
- Conversation storage: The application may retain messages locally or remotely, reload them later, or sync them across devices.
- Tooling and diagnostics: Traces, error reports and integrations may capture inputs or tool responses.
- Sharing: Links, exports, screenshots and collaborative sessions can expose the value to additional people or systems.
These are possible destinations, not a claim that every product logs every prompt in all of them. Check the particular client, model service, account settings and organisational agreement.
Training, retention and sharing are separate questions
“Not used for training” does not mean “never stored.” A service can exclude content from model training while retaining it for application features, security monitoring or other documented purposes.
Similarly, a setting that disables conversation history may not govern every trace or third-party integration.
OpenAI's API data-controls documentation, for example, distinguishes abuse-monitoring logs from application state and describes approval, eligibility and endpoint limitations for additional retention controls. Do not turn one provider's options into a universal promise about all vendors or account tiers.
Ask:
- Which service receives the prompt?
- What content is stored, where and for how long?
- Who can access it or share it?
- Which controls apply to this endpoint and feature?
- What deletion or retention exceptions remain?
An agreement reducing storage does not change the fact that a hosted service must process content sent to it.
A small example of unnecessary exposure
Suppose a developer pastes a payment key into a conversation to test an integration, then shares the conversation export for troubleshooting. This is an illustrative scenario, not a reported customer incident.
The integration may work, yet the key has reached another file and recipient. Its impact depends on its permissions, validity and further disclosure. Even a read-only key can expose sensitive data or consume paid resources.
The success of the original task is not evidence that its credential handling was appropriate.
If you already pasted a live key
Stop further distribution. Do not paste the value again while asking for help. Restrict sharing of affected messages, exports and logs.
Contain provider access. Assess the exposure promptly and restrict, revoke or replace the provider credential as appropriate. If active compromise is suspected, do not wait for a maintenance window merely to avoid disruption.
Coordinate legitimate consumers. Identify other systems using the same key. Where the provider supports overlap and the incident permits it, staged replacement can reduce interruption. Creating a replacement does not disable the old key.
Preserve evidence and use supported cleanup. Record relevant references and times without duplicating the secret. Use the client's supported deletion and retention controls, consistent with incident or legal preservation requirements. Deleting a visible conversation does not prove that exports, recipients, backups or other retained copies have been erased.
Investigate actual use. Check provider and runtime evidence. A retrieval log or the absence of an alert cannot prove that the key was never used.
Follow the incident-response playbook for a suspected compromise and the rotation versus revocation guide for provider and retrieval actions.
Choose a deliberate credential path instead
Prefer integrations that do not require manually inserting live keys into natural-language prompts.
A trusted tool can authenticate to a provider internally and return only the data needed for the task. That can keep the key away from the model, but the tool must actually implement that separation. Its allowed operations and outputs still need review.
Authenticated credential retrieval is different. Gazebo can check an agent's retrieval permissions and deliver an approved stored provider key through its SDK, CLI, API or MCP interface.
That workflow can avoid manual pasting, centralise access review and record retrieval attempts. The runtime and its host still receive the actual key. An MCP client may include tool responses in model context; a runtime may persist them in logs. Inspect the integration rather than assuming brokerage keeps values hidden.
Revoking Gazebo access blocks future retrieval. Provider invalidation is needed when retained copies must stop working.
Make the safer path usable
Document supported integrations, credential owners and handling rules before urgent work creates pressure for shortcuts. Use fictional test values in examples and support conversations.
Review code, agent configuration and logs for unintended disclosure. Give consumers only the provider permissions they need and check their actual execution environment.
The goal is not to declare one transport universally safe. It is to reduce unnecessary copies, understand which systems receive sensitive values and maintain a practical way to end unwanted access.