ChatGPT Temporary Chat Personalization Explained: Memory, Plugins, Custom Instructions, Saving, and Privacy

What changed in Temporary Chat personalization

OpenAI’s August 27 Temporary Chat controls changed the decision users make at the start of a temporary conversation: a Temporary Chat can remain non-personalized by default, or it can optionally use existing personalization sources such as memory, plugins, and custom instructions. The important operational shift is that “temporary” no longer always means “no personalization context is used.” It means the conversation is separated from normal chat history unless saved, and, according to OpenAI’s release-note description, it does not create new memories.

For ChatGPT Temporary Chat Privacy, How to Implement ChatGPT’s Dreaming Memory System in Enterprise Workflows: Architecture, Personalization Patterns, and Privacy Controls is the most relevant adjacent resource. The enterprise memory-architecture guide examines personalization and privacy controls at organizational scale, helping readers understand why a personalized temporary session still requires deliberate context and data-governance choices.

The optional mode is a personalized Temporary Chat. In that mode, OpenAI says the temporary conversation can use existing memory, plugins, and custom instructions. “Existing” is the key word: the temporary conversation can draw on personalization artifacts that already exist or plugin access that is already available, but it does not create new memories while the chat is temporary. This makes the mode useful when a user wants a short-lived working session that still understands established preferences, role context, or connected tools.

Operational rule: Treat Temporary Chat personalization as a start-of-session routing decision. Choose non-personalized Temporary Chat when you want isolation from account context. Choose personalized Temporary Chat when you want a disposable conversation that can still use already configured context. If you choose the wrong mode, start a new Temporary Chat rather than trying to change the mode midstream.

The personalization choice is made once, at creation

OpenAI’s release notes specify that personalization must be selected when the Temporary Chat starts and cannot be changed later in that chat. This matters for administrators, clinicians, researchers, and operators because the first click determines the context boundary for the entire conversation. A user cannot begin in non-personalized mode, inspect a response, then turn on memory or plugin context inside the same temporary thread. A user also cannot begin with personalization enabled and later convert that same temporary thread into a non-personalized thread.

The practical consequence is simple: if the first message requires account context, choose personalized Temporary Chat before entering the message. If the first message includes material that should not be influenced by prior memory or tool context, use the default non-personalized Temporary Chat. For example, a founder testing whether a pricing explanation is understandable to a first-time buyer may prefer non-personalized mode so the answer is not adapted to stored preferences. A developer asking the assistant to follow their usual coding style for a disposable refactor plan may prefer personalized mode if that style is already present in custom instructions or memory.

This creation-time constraint also prevents a common workflow mistake: using a Temporary Chat as a scratchpad and assuming personalization can be toggled later when the task becomes more serious. If a research analyst begins in non-personalized mode and later wants a plugin-backed evidence search, the safer workflow is to open a new personalized Temporary Chat with the correct tool context selected from the start, then copy only the non-sensitive task statement that is still needed.

Default Temporary Chat: non-personalized and out of history unless saved

In the default mode, a Temporary Chat is designed for a session that should not use account personalization and should not appear in normal chat history unless the user saves it. The absence from history is useful for reducing workspace clutter and separating exploratory work from retained projects. It should not be described as a guarantee that no processing, logging, compliance review, abuse monitoring, enterprise retention policy, or legal obligation can apply; OpenAI’s source language for this update specifically supports the history distinction and the saving behavior, not a universal anonymity guarantee.

For enterprise administrators, the phrase “out of history unless saved” should be translated into user training rather than policy assumptions. A user may think “temporary” means “safe for any sensitive information,” but the supported decision rule is narrower: Temporary Chat controls whether the conversation is kept in the user’s normal chat history and whether it creates new memories. Administrators should still enforce workspace data-handling rules, plugin policies, medical-data policies, and contractual obligations separately from the Temporary Chat setting.

For clinicians and healthcare operators, this distinction is especially important. A non-personalized Temporary Chat is not a substitute for an approved HIPAA-enabled workspace, an applicable Business Associate Agreement, or a configured clinical plugin policy. If a public-source healthcare plugin is involved elsewhere in the product, OpenAI’s healthcare guidance explicitly warns not to send protected health information to public sources. Temporary Chat mode does not turn a public-data app into a patient-chart system, and it does not authorize sending patient names, dates of birth, medical record numbers, member numbers, or other protected health information to tools that are not approved for that purpose.

Personalized Temporary Chat: existing context can be used, but new memories are not created

A personalized Temporary Chat is best understood as a short-lived workspace that can borrow from already available personalization. OpenAI identifies three relevant categories: existing memory, plugins, and custom instructions. Existing memory may help the assistant understand stable preferences or background already saved to the account. Custom instructions may shape tone, format, role assumptions, or recurring constraints. Plugins may provide access to enabled external or workspace-connected capabilities, subject to whatever availability, eligibility, permissions, and configuration rules apply to that plugin.

For ChatGPT Memory Controls, ChatGPT Memory and Personalization in 2026: How to Configure, Manage, and Optimize Your AI’s Long-Term Context is the most relevant adjacent resource. The memory and personalization guide explains how long-term context is configured and managed, making it easier to see what a temporary chat may read and what it does not add to memory.

This “read existing, do not write new” behavior creates a useful but bounded workflow. A product manager can run a temporary planning conversation that uses their established formatting preferences without adding every brainstormed idea to memory. A developer can ask for a disposable code-review checklist that follows their usual stack assumptions without teaching the assistant a new permanent project fact. A researcher can request an outline in their usual citation style without turning tentative hypotheses into saved personalization data.

Plugins in Temporary Chat require separate access and policy thinking

OpenAI’s release-note wording says personalized Temporary Chat can use plugins, but that does not mean every user automatically receives every plugin or that Temporary Chat bypasses workspace controls. Plugin availability and app access are governed separately. A plugin may require eligibility, administrator configuration, workspace policy approval, individual sign-in, or preexisting permissions. Temporary Chat personalization is therefore not an access-control grant; it is a choice about whether a temporary conversation may use already available personalization and tools.

For enterprise administrators, this separation should become part of rollout documentation. The Temporary Chat setting answers, “Can this temporary conversation use personalization?” Plugin policy answers, “Which tools can this account or workspace use, under what permissions, and for which data types?” Data governance answers, “What information may users enter into the model or send through a tool?” Confusing those layers can cause users to treat a temporary session as a compliance boundary when it is only one part of the product’s conversation-history and personalization behavior.

A safe workflow is to require users to identify the data class before choosing personalized Temporary Chat with plugins. Public information, synthetic examples, or non-sensitive internal process text may be appropriate in many ordinary workspaces. Regulated data, patient-specific information, customer secrets, security incident details, and contractual material require the organization’s approved workspace, plugin, retention, and access-control posture before use. Temporary Chat should be presented as a convenience and isolation feature, not as a blanket permission to process restricted data.

What saving a Temporary Chat changes

Saving is the conversion point. OpenAI says Temporary Chats remain out of history unless saved, and saving converts the conversation into a regular chat that follows account-level personalization and model-improvement settings. This is a major state change. Before saving, the thread is temporary and outside normal history. After saving, it becomes a regular chat, visible and governed like other retained conversations under the user’s account or workspace configuration.

Users should decide whether to save before they add sensitive or speculative material near the end of a temporary session. A common pattern is to use Temporary Chat for exploratory drafting, then save only if the conversation has become a durable project artifact. Once saved, the chat should be treated like any other retained work product: it may be discoverable to the user through history, subject to account-level personalization behavior, and governed by whatever model-improvement settings apply to that account or workspace. The source notes do not support claiming that saving preserves the earlier temporary boundary unchanged; OpenAI describes saving as conversion into a regular chat.

The safest operating procedure is to summarize before saving. Ask the assistant to produce a clean, non-sensitive summary of decisions, assumptions, and next steps, verify that summary manually, remove material that does not belong in a retained chat, and then save only if the resulting record is appropriate for normal history. This procedure is especially useful for teams that use ChatGPT as a working notebook but do not want every brainstorming path, rejected idea, or exploratory prompt retained as an ordinary conversation.

Recommended pre-save review prompt:
"Before I save this Temporary Chat, produce a concise record of only the durable decisions, assumptions, open questions, and next actions. Exclude exploratory alternatives, sensitive examples, personal data, credentials, patient information, and anything that should not become part of a regular retained chat. Do not add new facts; only summarize what is already in this conversation."

How to choose the right Temporary Chat mode

Choose the default non-personalized Temporary Chat when you want a clean-room answer, when prior preferences could bias the output, when you are testing how a general user might understand a topic, or when you are handling a one-off task that should not rely on memory, plugins, or custom instructions. This mode is also the safer default when a user is unsure whether a plugin or memory context could bring in information that is irrelevant to the task.

Choose personalized Temporary Chat when the task benefits from already established context but should not create new memories or remain in history unless saved. Good examples include applying an existing writing style to a disposable draft, using custom instructions for a temporary analysis format, or invoking an already available plugin for a short research task. Because the selection cannot be changed mid-chat, users should make that choice before they paste the task details or request tool-backed work.

Choose to save only when the conversation has become valuable as a regular chat. Saving is appropriate for durable project plans, implementation notes, reusable research summaries, or decisions that should remain accessible later. Saving is not appropriate merely because the conversation was useful in the moment; if the value is temporary, leave it temporary. If the chat contains regulated, confidential, or operationally sensitive content, verify workspace policy before saving and do not rely on the word “temporary” to override data-handling obligations.

Mode-by-mode comparison: ordinary chats, Temporary Chat variants, and saved conversions

OpenAI’s September 2026 release notes make the key operational distinction: Temporary Chat can now be started either without personalization or with optional personalization from existing memory, plugins, and custom instructions. That choice is made when the Temporary Chat starts and cannot be changed later, so teams should treat it like a session-classification decision rather than a cosmetic preference.

The practical issue is not whether one mode is “more private” in every possible sense; it is which data sources, account-level preferences, tools, and history behaviors can shape the answer. A clinician checking public drug-label wording, a founder testing messaging, a developer debugging code, and an administrator validating plugin policy may all need different modes because each task has a different tolerance for saved context, tool access, repeatability, and audit expectations.

Choosing a mode by work pattern, not by habit

Recommendation: start with the smallest amount of personalization that can produce a reliable answer. If the task is self-contained and all necessary facts can be pasted or summarized safely in the prompt, non-personalized Temporary Chat is usually the cleanest option because it reduces the chance that prior preferences, stored context, or standing instructions influence the result. This is useful when comparing vendor language, testing a prompt from a user’s perspective, or asking for a neutral second-pass critique.

Use a personalized Temporary Chat when the work is still temporary but prior context improves quality. A developer might want ChatGPT to remember a preference for TypeScript examples, an operator might rely on a standing instruction to return checklists instead of essays, or a researcher might want approved plugin access for a time-boxed evidence search. In those cases, personalization saves prompt space and reduces repetition, but the session still does not create new memories according to OpenAI’s release notes.

Use an ordinary chat when continuity is part of the job. If a team is iterating on an internal runbook, refining an architecture decision record, maintaining a long debugging thread, or producing a sequence of related deliverables, a regular conversation is easier to resume and review. The tradeoff is that the chat is no longer a temporary scratchpad, so users should confirm account and workspace settings before introducing confidential, regulated, or client-specific material.

Save a former Temporary Chat only when the work product has crossed from scratchpad to asset. For example, a founder may begin with a Temporary Chat to pressure-test positioning without previous brand preferences, then save it after the conversation produces a useful customer-interview script. The save decision should be intentional because OpenAI states that saving converts the conversation into a regular chat governed by account-level personalization and model-improvement settings.

How custom instructions change the answer

Custom instructions act like standing directions that can shape tone, format, assumptions, and recurring constraints when they are in scope. In a personalized Temporary Chat, OpenAI says custom instructions can be part of the optional personalization package, so a user who has instructed ChatGPT to produce concise tables, use a specific programming language, or ask clarifying questions before drafting may see those preferences reflected even though the chat is temporary.

In a non-personalized Temporary Chat, do not rely on custom instructions to carry the task. Put the needed rules directly in the prompt, such as “answer in a two-column risk table,” “do not use patient identifiers,” “show assumptions separately,” or “write the SQL for PostgreSQL.” This is the safest prompt design when you need reproducibility across accounts or want to test what a first-time user would receive without your standing preferences.

For ChatGPT Custom Instructions, 25 ChatGPT Custom Instructions Templates for Every Profession: Copy-Paste Configurations for Developers, Writers, Marketers, Researchers, and Managers is the most relevant adjacent resource. The profession-specific custom-instructions templates show the persistent guidance that can shape a personalized temporary chat even though the conversation itself remains outside normal history unless saved.

Example prompt for a non-personalized Temporary Chat:
You are helping me review a vendor security questionnaire response.
Use only the information in this prompt.
Return:
1. unsupported claims,
2. follow-up questions,
3. risks that require legal or security review.
Do not assume my usual preferences or prior project context.

Example prompt for a personalized Temporary Chat:
Use my existing formatting preferences if available.
Draft a temporary planning checklist for a migration review.
Do not create or rely on any new memory from this conversation.
If a tool is unavailable, say so rather than substituting unsupported facts.

How plugins and apps affect Temporary Chat output

Plugins can change a response by giving ChatGPT access to an external source or connected system that is not present in the prompt. OpenAI’s release notes say personalized Temporary Chats can use plugins, but plugin availability and app access are governed separately. That means selecting personalization is not an installation step, a permissions grant, or an administrator approval; it only allows eligible, configured plugin context to participate in that temporary session.

Administrators should separate three decisions: whether a user may start a personalized Temporary Chat, whether a plugin is installed or allowed in the workspace, and whether the user has authorization inside the connected system. This separation matters in regulated environments because a temporary interface does not eliminate the need for source-system access control, audit expectations, or data-handling rules.

Healthcare examples show why the distinction is operationally important. OpenAI describes Healthcare Public Data as read-only access to public healthcare sources for eligible US users and workspaces; it does not access patient charts, and OpenAI warns not to send protected health information to public sources. A personalized Temporary Chat may be convenient for a clinician or researcher using approved public evidence, but it must not be used to paste patient names, dates of birth, medical record numbers, member numbers, or other PHI into public-data tools.

OpenAI also describes a separate Epic plugin for approved ChatGPT for Healthcare and HIPAA-enabled Enterprise workspaces, with read-only access to authorized patient information after administrator configuration, individual Epic sign-in, and enforcement of existing patient-chart permissions. A Temporary Chat setting does not expand Epic permissions, does not make Epic available to ineligible accounts, and does not change the fact that organizations must confirm the applicable Business Associate Agreement and approved workspace configuration before using Epic with protected health information.

Operational rule: treat plugins as governed data paths, not as convenience features. If the plugin source is public, do not send private patient or customer identifiers to it. If the plugin source is an internal or clinical system, verify workspace approval, user authorization, and source-system permissions before relying on the output.

Why “personalized” does not mean “new memory”

The most common misunderstanding is to read “personalized Temporary Chat” as “a Temporary Chat that can learn new facts about me.” OpenAI’s release notes draw a different boundary: personalized Temporary Chats can use existing memory, plugins, and custom instructions, but they do not create new memories. In practical terms, the session may be shaped by previously available context, but the temporary conversation itself is not a memory-writing channel.

A useful mental model is “read existing context, do not write new memory.” If existing memory says a user prefers Python examples, a personalized Temporary Chat may provide Python examples. If the user then says, “From now on, remember that I prefer Rust,” the temporary session should not create a new memory from that instruction. The user should manage persistent preferences through the normal memory or account controls rather than expecting a temporary session to update them.

This boundary is especially important for clinicians, researchers, and enterprise operators. A user might temporarily ask ChatGPT to draft a de-identified patient-education template, summarize public Medicare coverage information, or compare clinical-trial criteria from public sources. Even when the chat is personalized, users must verify the answer against underlying sources, avoid sending PHI to public-data plugins, and avoid assuming that a temporary session has recorded durable preferences for future compliance workflows.

The boundary also matters for debugging. Suppose a developer opens a personalized Temporary Chat, says “for this conversation, assume our service uses queue-based retries,” and receives useful architecture advice. That assumption can guide the temporary session, but OpenAI’s stated behavior means the chat does not create a new memory that future conversations will automatically know about queue-based retries. If the assumption should become part of an ongoing project context, the user should move the work into an appropriate regular workflow and verify the relevant account settings.

Decision checklist before starting the session

1. Decide whether previous context should influence the answer. If not, start a non-personalized Temporary Chat and include all necessary constraints directly in the prompt.
2. Decide whether the work may become persistent. If you already expect to resume it later, an ordinary chat may be more appropriate than saving a temporary one after the fact.
3. Check whether tools are required. If the answer depends on plugins or apps, confirm eligibility, installation, workspace policy, and user authorization before starting.
4. Classify the data before pasting it. Do not place PHI, regulated customer data, credentials, secrets, or contractually restricted material into a mode or plugin path that is not approved for that data.
5. Record the reason for saving. If a Temporary Chat is saved, note why the conversation should become a regular chat, because the governance category changes at that point.

Practical default: use non-personalized Temporary Chat for clean-room exploration, personalized Temporary Chat for short-lived work that benefits from existing preferences or approved tools, ordinary chat for durable projects, and saved former Temporary Chat only when the scratchpad has produced a work product worth preserving under regular chat behavior.

Decision rules for real Temporary Chat work

Temporary Chat is most useful when you treat it as a session boundary, not as a privacy magic wand. OpenAI says a Temporary Chat can now be started either without personalization or with optional personalization from existing memory, plugins, and custom instructions; that choice is made when the chat starts and cannot be changed later. The operational question is therefore not “Is Temporary Chat private?” but “Which context should this session be allowed to use, which tools should it touch, and should the output remain outside chat history or be saved into a regular chat?”

For ChatGPT Privacy Settings, The Complete Guide to ChatGPT-5.5 Memory and Personalization: How to Train Your AI Assistant to Understand Your Work Style is the most relevant adjacent resource. The GPT-5.5 memory and personalization guide walks through user-facing context controls, providing the settings background needed before choosing whether a temporary chat should inherit personalization.

Fast triage: choose the lowest-context mode that can complete the task

Sensitive drafting: minimize before you paste

For sensitive drafting, start with a default Temporary Chat unless personalization is essential to the deliverable. A resignation letter, incident summary, contract negotiation memo, personnel note, security disclosure draft, or clinical-policy explanation can usually be improved from a redacted summary, not the raw file. Replace names with roles, replace exact dates with relative timeframes where precision is unnecessary, and remove account numbers, addresses, patient identifiers, internal credentials, and confidential counterparties before asking for structure, tone, risk flags, or alternative wording.

Recommended workflow: draft in three passes. In pass one, ask for an outline using abstract facts. In pass two, add only the minimum missing facts required to improve accuracy. In pass three, perform a human review against the source material before sending or filing anything. This approach is especially important because Temporary Chats do not create new memories, but the model can still use the contents of the active session to answer later turns in that same session, and any connected tool you invoke may have its own data boundary.

Example sensitive-drafting prompt:
I need help improving the structure and tone of a confidential workplace memo.
Use only the anonymized facts below. Do not infer names, legal conclusions, or policy violations.
Return:
1. a neutral executive summary,
2. a risk-neutral timeline,
3. questions I should verify against source documents,
4. wording that avoids overclaiming.

Anonymized facts:
- Employee A reported a process concern after a team meeting.
- Manager B responded two business days later.
- The issue affects approval workflow documentation, not customer data.

One-off research: decide whether the query trail is worth keeping

One-off research is a strong fit for Temporary Chat when the result is a bounded answer: “summarize the current public guidance,” “compare these three APIs,” “extract decision criteria from these documents,” or “prepare questions for a vendor call.” If the task does not require your existing memory, start without personalization. If custom instructions would materially improve the format—such as always returning a table with confidence notes—you can choose personalization at the start, but remember that the session still will not create new memories.

The main risk in research sessions is accidental scope creep. A user begins with public material, then adds internal data to “make it more relevant,” then invokes a plugin or app that was not part of the original plan. To prevent this, define the source class before beginning: public-only, internal-document-only, account-connected, or regulated. If the answer must cite public sources, require citations or source names and verify them against the original sources before relying on the result. If the research concerns healthcare public data, do not add patient names, dates of birth, medical record numbers, member numbers, or other protected health information to a public-data workflow.

Travel planning: separate preferences from credentials

Travel planning is a common case where personalization can be helpful but still should be limited. Existing preferences such as “prefers morning flights,” “needs quiet hotels,” or “travels with children” may improve recommendations if those preferences already exist in memory or custom instructions and you choose personalized Temporary Chat at the start. However, the model does not need passport numbers, payment card details, loyalty-account passwords, full home addresses, or scans of identity documents to compare neighborhoods, build a packing list, or draft a day-by-day itinerary.

Use a staged approach. In the exploratory stage, provide only destination, dates or date ranges, budget category, mobility constraints, and preference summaries. In the booking stage, move to the approved booking system or vendor site rather than treating the chat as the system of record. If you later save the conversation because the itinerary is useful, first remove unnecessary personal details from the working plan and confirm that the saved chat will be appropriate under your account settings and any organization policy that applies to the workspace.

Account-connected work: map what the tool can read before you ask

Account-connected work deserves a higher bar than ordinary drafting because the model may be able to use plugin or app context that is governed separately from Temporary Chat history. Before using any connected tool, identify what the tool can access, whether access is read-only or action-capable, whether permissions come from the user or the workspace, and whether the connected service receives prompt content or query parameters. Temporary Chat can reduce chat-history persistence, but it does not by itself redefine the permission model of a connected account.

For ChatGPT Plugin Security, How to Import and Govern ChatGPT Plugin Marketplaces from GitHub: Enterprise Workspace Playbook is the most relevant adjacent resource. The plugin-marketplace governance playbook details workspace policy, app access, and authentication boundaries, which remain relevant when a temporary chat is allowed to use connected plugins.

Healthcare and regulated work: public sources and private records are different categories

OpenAI’s healthcare plugin notes make the category distinction explicit. Healthcare Public Data is described by OpenAI as read-only access to nine public healthcare sources for eligible users, including sources for research, clinical trials, medication information, Medicare data, and provider records; it does not access patient charts. OpenAI also warns that protected health information must not be sent to public sources. Therefore, a Temporary Chat using public healthcare sources should be treated as public-evidence research, not as a patient-specific chart review environment.

Epic is a separate case. OpenAI describes the Epic plugin as read-only access to authorized patient information for eligible ChatGPT for Healthcare and HIPAA-enabled Enterprise workspaces after administrator configuration, individual Epic sign-in, and enforcement of existing patient-chart permissions. It cannot be treated as a general public-data tool, and it should not be assumed available to every user. Organizations must confirm the applicable Business Associate Agreement, approved workspace configuration, user authorization, and local policy before using protected health information in any approved healthcare workflow.

For regulated work outside healthcare, apply the same separation principle. Legal analysis, financial review, employment decisions, student records, security investigations, and government workflows may impose retention, access, audit, and confidentiality obligations that are independent of ChatGPT’s chat-history behavior. Temporary Chat is a session option; it is not a substitute for record-retention schedules, matter-management systems, audit logs, supervisory approval, or professional judgment. When in doubt, use anonymized hypotheticals in Temporary Chat and place verified conclusions in the approved system of record.

Clinical and regulated-work warning: this article is educational and operational guidance, not medical, legal, compliance, or security advice. Users must verify outputs against underlying records, official sources, and organizational policy. Do not send protected health information to public-data apps, and do not use a temporary session to bypass workspace, chart, client, student, or customer-data rules.

Plugin testing: use synthetic fixtures and expected outcomes

Plugin testing is safest when it begins with synthetic fixtures: fake names, fake account IDs, fake ticket numbers, invented medication examples that are clearly marked as test cases, or non-sensitive public records. The goal is to learn how the plugin behaves, what prompts produce reliable outputs, and where human approval is needed, without exposing real data during experimentation. Temporary Chat is useful here because failed experiments do not need to become part of chat history unless you deliberately save the useful test case.

Create a test matrix before invoking the tool. Include the user goal, the allowed data class, the plugin or app to be tested, the expected output, and the condition that should stop the test. For example, a stop condition might be “the model asks for credentials,” “the workflow requires patient-specific data but only public-data tools are enabled,” or “the tool appears to need write access for a task that should be read-only.” If a test reveals a useful workflow, save a cleaned version that contains the prompt pattern, synthetic inputs, observed limits, and human-review checklist.

Example plugin-test record:
Purpose: Test whether the tool can summarize public source results.
Data class: Synthetic and public-only.
Do not include: customer names, PHI, credentials, internal IDs, private files.
Expected output: source list, summary, uncertainty notes, verification steps.
Stop if: the task requires private account data or the tool boundary is unclear.
Save criteria: save only if the final prompt is reusable and contains no real sensitive data.

Brainstorming: keep throwaway ideas temporary, preserve decisions deliberately

Brainstorming often benefits from a Temporary Chat because most ideas are disposable. Use the default mode when you want a clean room for naming, positioning, feature alternatives, meeting formats, or implementation options. Use personalized Temporary Chat when existing custom instructions or remembered preferences meaningfully improve the session, such as a founder wanting ideas in a specific brand voice or an engineering lead wanting proposals constrained by a known stack. The key is to avoid letting convenience pull sensitive strategy or unreleased plans into a casual ideation thread without a save policy.

At the end of a brainstorming session, separate raw ideation from decisions. Raw lists, jokes, rejected names, speculative acquisition ideas, or unreviewed legal theories usually do not need to be saved. Decisions, however, may need preservation: a product brief, research agenda, hiring rubric, incident-response checklist, or architecture tradeoff table. Before saving, delete irrelevant sensitive material if possible, add a note that outputs require human verification, and make sure the saved conversation belongs in the same account context that will govern future personalization and model-improvement settings.

When a temporary conversation becomes valuable

The most subtle Temporary Chat decision happens after the session succeeds. A conversation that began as disposable may produce a reusable prompt, a clean policy checklist, a vendor-evaluation matrix, a research synthesis, a training example, or a structured plan. OpenAI says saving a Temporary Chat converts it into a regular chat, which means it is no longer merely an out-of-history temporary session. Treat that conversion as a records decision: you are deciding that the content should persist in the ordinary chat environment under the account-level controls that apply there.

Use a save gate with four questions. First, does the conversation contain personal, customer, patient, employee, confidential, or regulated data that should not persist in this account? Second, would a shorter sanitized artifact be better than saving the full transcript? Third, will future personalization or workspace policy make the saved chat useful or risky? Fourth, is the conversation needed for continuity, auditability, training, handoff, or reuse? If the value is only the final answer, copy the verified answer into the appropriate system and leave the exploratory transcript unsaved.

1. Save the chat when the whole reasoning path, prompt sequence, or source trail will be reused and the content is appropriate for regular chat handling.
2. Save a cleaned derivative when the workflow is valuable but the transcript includes unnecessary sensitive facts, identifiers, or tool outputs.
3. Do not save when the session served a one-time purpose, contains data that should not persist, or belongs in a regulated system of record instead of chat history.
4. Restart in the correct mode when you realize midstream that the initial choice was wrong, because the personalization setting cannot be changed inside the existing Temporary Chat.

Consent and data minimization checklist before the first prompt

Consent is not only a legal formality; it is a practical boundary for what the user, organization, patient, customer, employee, or counterparty would reasonably expect to be used in an AI-assisted workflow. Before entering third-party information, ask whether you have authority to use it for this purpose, whether the person or organization has been told how the information may be processed, and whether a less identifiable version would work. In enterprise and clinical settings, individual authority is not enough if workspace configuration, app policy, contract terms, or retention rules prohibit the workflow.

Data minimization turns that consent analysis into an editing procedure. Replace identities with roles, aggregate counts, narrow excerpts, synthetic examples, or issue summaries. Do not upload entire contracts, charts, inbox exports, customer records, logs, or datasets when a paragraph or schema is sufficient. Do not combine unrelated data classes in one chat just because the session is temporary. A Temporary Chat about a product launch should not also contain employee medical details, customer credentials, or unreleased security vulnerabilities unless an approved workflow explicitly requires those data and the appropriate tool boundary has been verified.

The final rule is simple: start with the least personalized, least connected, least identifying setup that can answer the question. Add personalization only when existing memory or custom instructions materially improve the result. Add plugins only when the task requires an external source or authorized account context. Save only when persistence creates more operational value than risk. That discipline is what makes Temporary Chat personalization useful for real work rather than merely another mode to choose out of habit.

Operational guardrails for Temporary Chat

OpenAI’s September 2026 release notes make Temporary Chat more flexible, but the operational rule remains simple: decide the privacy and context boundary before the first prompt. A Temporary Chat can now be started either without personalization or with optional use of existing memory, plugins, and custom instructions. That choice is made when the chat starts and, according to OpenAI, cannot be changed later in the same conversation.

The safest operating posture is to treat Temporary Chat as a session-scoping feature, not as a universal privacy, compliance, or access-control feature. Temporary chats do not create new memories and remain outside chat history unless saved, but a personalized Temporary Chat can still use context that already exists at the account or workspace level. If the session uses plugins or connected apps, the output can also reflect information returned by those tools, subject to the separate permissions and policies governing those tools.

Safe operating checklist for individuals and teams

1. Classify the task before opening the chat. Use non-personalized Temporary Chat for one-off drafting, ideation, question answering, or analysis where prior preferences are unnecessary. Use personalized Temporary Chat only when existing instructions, memories, or approved tools materially improve the result.
2. Decide whether the work should be recoverable. If the conversation needs to become a record, project artifact, handoff note, research trail, or compliance evidence, Temporary Chat may be the wrong starting point. OpenAI says saving a Temporary Chat converts it into a regular chat governed by account-level personalization and model-improvement settings.
3. Minimize inputs before pasting. Remove secrets, credentials, patient identifiers, customer account numbers, internal incident details, and unpublished commercial commitments unless the workspace, tool, and policy explicitly allow that data category. Temporary Chat does not make unsafe input safe.
4. Check whether personalization is actually required. If the task can be completed by pasting a short brief, choose the lower-context route. For example, “rewrite this announcement for engineers” rarely needs memory, while “apply my usual executive-summary format” may depend on custom instructions.
5. Map plugin data boundaries. Before invoking a plugin, identify whether it reads public data, private workspace data, or regulated records. OpenAI describes Healthcare Public Data as read-only public-source access and separately describes the Epic plugin as read-only access to authorized patient information after administrator configuration and individual sign-in.
6. Never send PHI to public-data plugins. OpenAI explicitly warns that protected health information must not be sent to public sources. Patient names, dates of birth, medical record numbers, member identifiers, and similar details should not be included in prompts to public healthcare data sources.
7. Keep human review where decisions matter. Temporary Chat can support drafting, comparison, summarization, and planning, but it should not be the final authority for clinical decisions, legal conclusions, production changes, financial approvals, or customer commitments.
8. Record the decision when a temporary session becomes important. If the chat produces a useful policy, diagnosis-support summary, engineering plan, or customer-response draft, either save it intentionally or copy the vetted result into the organization’s system of record with source references and reviewer notes.

Misconceptions that cause avoidable mistakes

Troubleshooting personalization and tool behavior

When personalization is unavailable

If the personalized Temporary Chat option is not available, first verify that the feature is available for the account, workspace, and region in question by checking OpenAI’s current release notes and relevant help-center pages. OpenAI often rolls features out by plan, workspace eligibility, geography, or product surface, and the September 2026 notes describe optional personalization as a Temporary Chat capability without implying that every account has identical access to every connected app or plugin.

Next, distinguish the Temporary Chat feature from plugin access. A user may be able to start a Temporary Chat but still lack access to a specific plugin because the plugin has not been enabled, the workspace administrator has not approved it, the user has not completed a required sign-in, or the underlying app is unavailable for that workspace. OpenAI’s healthcare notes are a good example: Healthcare Public Data and Epic are governed separately, and Epic requires administrator configuration plus individual Epic sign-in.

For enterprise or healthcare workspaces, ask an administrator to confirm whether workspace policies restrict memory, custom instructions, plugins, or app connections. Do not attempt to bypass a missing capability by pasting regulated records or private data into a different tool. Missing personalization is usually a configuration, eligibility, or policy issue; it is not a reason to downgrade data-handling controls.

When output appears unexpectedly personalized

If a Temporary Chat produces a response that reflects your usual style, preferred format, role, location, project vocabulary, or connected data, assume the session may have been started with personalization. Because the setting cannot be changed mid-chat, the cleanest fix is to start a new Temporary Chat without personalization and restate only the minimum context needed to complete the task.

If the answer cites or appears to use external records, check whether a plugin or app was active. Tool-grounded output may reflect plugin results rather than memory. In regulated environments, this distinction matters: public evidence retrieval, private workspace search, and read-only EHR context have different permission boundaries and different review obligations.

If the issue persists across new non-personalized temporary sessions, review account-level custom instructions and memory settings where available, and check whether the prompt itself contains cues that explain the behavior. A prompt such as “use my usual board memo structure” can cause the model to infer a format from the text provided in the same conversation, even if no memory is being used.

When a saved conversation behaves differently afterward

If a Temporary Chat is saved, treat subsequent behavior as regular-chat behavior. OpenAI states that saving converts the conversation into a regular chat governed by account-level personalization and model-improvement settings. That means the saved conversation may become part of the user’s ordinary chat environment rather than remaining under the expectations the user associated with a temporary session.

Use a short audit note when saving matters: record why the chat was saved, what sources were used, whether any plugin was invoked, and whether the output was reviewed before reuse. This is especially important for clinical research summaries, enterprise incident notes, sales account plans, policy drafts, and engineering implementation plans that may later be treated as authoritative.

Sample diagnostic prompt for a new non-personalized Temporary Chat:

You are helping me troubleshoot whether this session is using only the information I provide here.
Do not rely on prior preferences, memory, custom instructions, or connected tools.
Task: Rewrite the following paragraph in plain English.
Source text: [paste non-sensitive text only]
If you need context not included here, ask for it instead of assuming it.

Team-policy considerations for administrators and operators

Administrators should define Temporary Chat policy by data class and work pattern rather than by personal preference. A practical policy can say, for example, that non-personalized Temporary Chat is acceptable for low-risk brainstorming, that personalized Temporary Chat is acceptable for approved productivity workflows, and that regulated records require approved workspaces, approved plugins, and human review. This avoids a vague rule such as “use Temporary Chat for sensitive work,” which can be misleading.

Workspace policy should also specify when saving is permitted. Saving can be useful when a temporary exchange becomes a durable work product, but it changes the conversation’s status. Teams should decide whether saved chats may contain customer data, clinical context, source excerpts, security findings, or internal strategy, and where the final reviewed artifact should live if the chat itself is not the system of record.

Plugin governance needs a separate control plane. Installing or enabling a plugin should not be treated as blanket approval for all data. Healthcare Public Data, for example, is useful for public evidence lookups across sources such as ClinicalTrials.gov, CMS Coverage, RxNorm, DailyMed, and PubMed, but OpenAI says it must not receive protected health information. Epic is a separate read-only plugin for approved ChatGPT for Healthcare and HIPAA-enabled Enterprise workspaces, and it inherits existing patient-chart permissions rather than expanding them.

For Enterprise ChatGPT Data Controls, How to Build Enterprise Data Loss Prevention Policies for ChatGPT and Codex: Complete Implementation Guide is the most relevant adjacent resource. The enterprise data-loss-prevention implementation guide covers policies for sensitive prompts, connected tools, and outbound data, extending the per-chat decision into organization-wide controls.

Training should include realistic failure cases. Show users a non-personalized temporary session, a personalized temporary session that reflects custom instructions, a plugin-assisted session, and a saved conversion. The goal is to make the boundary visible: temporary status, personalization status, plugin status, and saved status are related but not identical.

Operational rule: use the least context that can complete the task, use only approved tools for the data category, and save only when the conversation should become a regular chat or when the vetted result has been moved into an approved record system.

Conclusion: use Temporary Chat deliberately

Temporary Chat personalization gives users a more nuanced choice: a session can stay temporary while still drawing on existing personalization and approved tools, or it can remain non-personalized for lower-context work. The important operational detail is that this choice is made at the start and cannot be changed inside the same chat.

For most users, the safest default is non-personalized Temporary Chat unless prior context or a specific approved plugin is necessary. For teams, the safest policy is to define the allowed mode by data class, tool boundary, and recordkeeping requirement. Temporary Chat can reduce unwanted history clutter and limit new memory creation, but it does not replace data minimization, plugin governance, source verification, or human accountability.

Useful Links

• OpenAI product release notes — official release-note source for Temporary Chat personalization, saving behavior, healthcare plugin availability, and related product updates.
• ChatGPT release notes — help-center release notes for ChatGPT features and rollout details.
• OpenAI: healthcare organizations can connect EHR and industry data to ChatGPT — official overview of healthcare public data, Epic context, workspace requirements, and PHI boundaries.
• OpenAI Help: Using Healthcare Public Data in ChatGPT and Codex — operational guidance for the read-only public healthcare sources and the prohibition on sending PHI to public sources.
• OpenAI Help: Using the Epic plugin with ChatGPT and Codex — official requirements and limits for read-only Epic access in approved workspaces.
• OpenAI Help: ChatGPT for Healthcare — workspace-level healthcare information including role-based access, single sign-on, audit logs, and HIPAA-enabled configuration context.