OpenAI Dreaming V3: ChatGPT Now Learns While You Sleep

Privacy Model and What Is Actually Stored

The most important question about any persistent memory system: what exactly is being stored, where, and who can access it?

OpenAI’s published data sheet for Dreaming V3 states:

• Memory fragments and chains are stored in your OpenAI account, not tied to individual conversations
• Raw conversation content is not stored as memory — only the extracted fragments
• Consolidation processing happens on OpenAI’s servers in US East and EU West regions
• Memory data is included in OpenAI’s standard data retention period (30 days after account deletion by default)
• Business/Enterprise accounts can configure memory data retention separately under their DPA

Dreaming V3 is opt-in for EU users due to GDPR requirements. For US Plus and Pro subscribers, it is opt-in by default — you had to manually turn on Memory in Settings already, and Dreaming V3 activates for accounts that had Memory enabled.

The control surface in Settings > Personalization > Memory now shows three new options: view memory chains (read-only), disable idle consolidation (memory still works but no background processing), and purge all chains (non-reversible). You can still see and delete individual memories as before.

One privacy nuance worth noting: the proactive surfacing feature means the model makes relevance judgments about your memory before you have given it any context for the current conversation. If that makes you uncomfortable — the model deciding what from your history is relevant to your current query without being asked — the disable-idle-consolidation option turns off the background processing while keeping manual memory saves.

How It Compares to Claude’s Memory Model

Claude does not have a native persistent memory system equivalent to Dreaming V3. Anthropic’s approach has been project-level memory via CLAUDE.md files and session-level context via the 1M token window. This is a deliberate architectural choice, not an oversight.

Feature	ChatGPT Dreaming V3	Claude
Cross-session memory	Yes, automatic	Project files only (CLAUDE.md)
Idle consolidation	Yes, background job	No
Memory chains/relationships	Yes	No
Proactive surfacing	Yes	No
User control over memory content	Partial (view chains, delete)	Full (you write CLAUDE.md)
Memory persistence across devices	Account-level (all devices)	File-level (wherever CLAUDE.md lives)
Memory for programmatic API use	New API endpoints (below)	Stateless (you manage context)

The tradeoff is legibility and control. Claude’s CLAUDE.md model is explicit — you wrote it, you can read it, you know exactly what context the model has. Dreaming V3’s memory chains are inferred and opaque — you can view them but not edit them directly. For personal productivity use, opaque but convenient wins for most users. For professional or sensitive contexts, explicit and controllable is safer.

Mem0, the third-party memory layer that works across Claude, GPT, and Gemini, released Dreaming V3 support on June 5 — one day after the OpenAI launch. Their approach stores memory externally and injects it at session start, giving you the chain-based organization without the OpenAI lock-in.

Developer API Access: What Changed in the ChatGPT API

The ChatGPT API (separate from the standard OpenAI completions API) now exposes memory operations through three new endpoints added June 4:

// Read memory chains for a user
GET /v1/users/{user_id}/memory/chains
Authorization: Bearer {api_key}

// Response structure
{
  "chains": [
    {
      "id": "chain_abc123",
      "root_fragment": "prefers TypeScript over JavaScript",
      "related_fragments": [
        {
          "fragment": "currently building a Next.js 16 project",
          "relationship": "provides-context-for",
          "weight": 0.87
        }
      ],
      "created_at": "2026-05-14T08:22:00Z",
      "last_consolidated_at": "2026-06-04T03:15:00Z"
    }
  ],
  "total_chains": 23,
  "last_consolidation_run": "2026-06-04T03:15:00Z"
}

// Delete a specific chain
DELETE /v1/users/{user_id}/memory/chains/{chain_id}

// Inject a memory fragment (bypasses idle consolidation, immediate)
POST /v1/users/{user_id}/memory/fragments
Content-Type: application/json

{
  "fragment": "User is building a fintech app with Razorpay integration",
  "source": "developer_injected",
  "weight": 1.0
}

Access to the user-level memory API requires the ChatGPT Enterprise API tier, not the standard completions API. Enterprise API is separate from the Plus/Pro subscription — it is the programmatic access layer for building ChatGPT-powered applications with user accounts.

For most developers who use the standard api.openai.com completions endpoint (GPT-4.1, GPT-4o, etc.), Dreaming V3 is not accessible. Those API calls are stateless by design. Memory is a ChatGPT platform feature, not a raw model feature.

The Practical Impact on ChatGPT-Based Workflows

Three workflows where Dreaming V3 makes a measurable difference:

Long-term personal assistant use. If you use ChatGPT as an ongoing assistant for project management, writing, or research, the proactive surfacing reduces the amount of context-setting you do at the start of each session. Early user reports suggest 30–40% fewer "here is what I’m working on" preambles per week in high-frequency users.

Learning contexts. If you use ChatGPT to learn something (a programming language, a subject area) across multiple sessions over weeks, memory chains build an accurate model of what you already know. Explanations stop re-covering covered ground without being told to.

Code context continuity. For developers who use ChatGPT chat (not Claude Code terminal) for coding help, memory chains retain your tech stack, current project context, and code style preferences. This is less powerful than Claude Code’s CLAUDE.md which is per-project and editable, but it is automatic.

The weak spot: memory chains work across all your ChatGPT conversations. If you use ChatGPT for radically different purposes — work and personal, multiple projects with different constraints — the cross-contamination of memory chains can surface irrelevant context. OpenAI does not yet have project-level memory isolation. That is the feature gap Anthropic’s Projects feature addresses directly.

For managing complex multi-model AI workflows, browse the AI productivity tools at WOWHOW, and use the AI API cost calculator to model your ChatGPT Enterprise API usage before committing to the tier.

People Also Ask

Is ChatGPT Dreaming V3 available on the free plan?

No. Dreaming V3 requires ChatGPT Plus ($20/month) or Pro ($200/month) as of the June 4, 2026 launch. The feature requires account-level memory to be enabled, which has been a Plus-and-above feature since early 2025. OpenAI has not announced a free-tier rollout date.

How do I see what memories ChatGPT has about me?

Go to Settings > Personalization > Memory > Manage memories. With Dreaming V3, you will now see a "Memory Chains" view in addition to the individual memories list. The chains show the inferred relationships. You can delete individual memories or entire chains, but you cannot directly edit chain relationships — only the model’s consolidation process writes chain edges.

Does Dreaming V3 affect ChatGPT API calls?

Standard OpenAI API completions (api.openai.com/v1/chat/completions) are unaffected — those calls are stateless and memory-agnostic. Dreaming V3 memory operations are available only through the ChatGPT Enterprise API, which is a different endpoint tier for building applications that use ChatGPT user accounts.

How is Dreaming V3 different from the memory system Claude has?

Claude does not have a native cross-session memory system. Claude uses CLAUDE.md project files for persistent context, which you write and control explicitly. Dreaming V3 is automatic and inferred. The practical tradeoff: Dreaming V3 requires zero maintenance but is opaque; CLAUDE.md requires you to write it but is fully transparent and controllable. For personal assistant use, Dreaming V3 wins on convenience. For professional codebases and sensitive contexts, CLAUDE.md’s explicit model is safer.