The ChatGPT apps, projects, and memory

The mobile app (iOS and Android) is built for input you can't easily type: voice mode for hands-free conversation, the camera for "what is this" questions, and photo uploads from your library. Advanced Voice is the standout here.

The mental model: start serious work on web, capture and dictate on mobile, and use desktop when you want ChatGPT aware of what's already on your screen. Your chats, Projects, and memory sync across all three.

Projects: a scoped workspace, not just a folder

A Project is a container that bundles three things: a set of chats, uploaded files, and custom instructions that apply *only* inside that container. Think of it as a sandbox with its own brief and its own reference shelf.

Why this matters: your global custom instructions and global memory are great defaults, but they leak across everything. A Project lets you set instructions and load files that are relevant to one body of work, without polluting the rest of your account.

What lives inside a Project

• Project instructions. A scoped system prompt. Anything you write here is prepended to every chat in the Project.
• Project files. Documents you upload once and reference from any chat in the Project. ChatGPT retrieves from these automatically when relevant.
• The chats themselves. Every conversation started inside the Project stays grouped there.

A key behavior: memory is contained inside Projects. Chats inside a Project don't read from or write to your global memory by default, and what happens in one Project stays scoped to it. That isolation is the whole point. See OpenAI's Projects help article for the current specifics, since limits and behaviors get updated.

A concrete Project: the "Northwind Retail" client

Say you consult for a client, Northwind Retail, on a quarterly basis. Without a Project, every new chat starts cold: you re-paste their brand voice, re-explain their product lines, re-upload the same brief. Tedious and error-prone.

Create a Project called Northwind Retail. Set the instructions:

Then upload the reference shelf as Project files:

• northwind-brand-guide.pdf
• q3-sales-by-sku.csv
• 2025-marketing-calendar.xlsx
• store-locations.csv

Now every chat in this Project already knows the voice, the audience, and the data. You open a new chat and ask: *"Draft three email subject lines for the fall jacket promo, then tell me which SKUs from the sales file are trending down."* ChatGPT applies the brand voice from instructions and pulls numbers from q3-sales-by-sku.csv without you uploading anything again.

Stacking project files with advanced data analysis

Project files become genuinely powerful when combined with Advanced Data Analysis (Code Interpreter), the sandboxed Python environment inside ChatGPT. Because your CSV is already on the Project shelf, you can say:

*"Using the sales file, chart weekly revenue by category and flag any category that dropped more than 15% week over week."*

ChatGPT writes and runs real Python against the file, returns the chart, and explains the dips, all within the Project's brand-aware context. No re-upload, no re-promptingpromptingPrompt engineering is the practice of designing and refining text inputs to guide large language models toward accurate, relevant, and reliable outputs.View full definition → the voice.

When to split into multiple Projects

One Project per ongoing client or per major workstream. If you also write Northwind's internal HR docs, that's a *different* tone and a different file set: make a second Project. The isolation keeps the brand-voice instructions from bleeding between unrelated work.

Memory: what ChatGPT carries between chats

Memory is ChatGPT's ability to remember details across separate conversations so you don't repeat yourself. It comes in two parts.

Saved memories are specific facts ChatGPT chooses to store, like "User is a consultant" or "User prefers metric units." You can see them in Settings → Personalization → Memory, and you can delete any one of them.

Chat history reference is broader: ChatGPT can draw on the themes and context of your past conversations to make new answers more relevant, even without an explicit saved memory.

Both are toggles. Both live under Personalization. The full, current rules are in OpenAI's Memory FAQ.

How memory helps in the Northwind example

Outside the Project, in your everyday chats, memory learns that you're a consultant who writes for retail clients, prefers concise drafts, and works in USD. So when you start a quick unrelated chat to outline a proposal, ChatGPT already matches your style. That's the upside: less re-explaining, more continuity.

Inside the Northwind Project, the *Project instructions* do this job instead, scoped tightly to that client. This is the clean division of labor: global memory for your durable personal defaults, Project instructions for client-specific or task-specific context.

When to turn memory off

Turn it off (or use a Temporary Chat) when:

• You handle multiple clients with conflicting context. You don't want a stray fact about Northwind surfacing while you draft for a competitor. Project isolation handles most of this, but for ad hoc chats outside any Project, a Temporary Chat is the safe move.
• You're doing sensitive or one-off work. A Temporary Chat starts a session that doesn't use memory, doesn't update memory, and doesn't appear in history. Ideal for confidential exploration.
• Memory has gone stale. If ChatGPT keeps assuming an outdated fact (an old job title, a past project), open the memory list and delete the offending entry rather than fighting it in conversation.

You can ask ChatGPT directly: *"What do you remember about me?"* and it will list its saved memories. You can also say *"Forget that I work at Northwind"* and it will drop that specific memory.

How this connects to the rest of the ecosystem

Projects and memory are the *personal* layer. They sit alongside the more programmable parts of the OpenAI ecosystem, and knowing the boundaries keeps you from reaching for the wrong tool.

Custom GPTs are shareable, packaged assistants with their own instructions, knowledge files, and optionally GPT Actions (calls out to external APIs). A Project is for *your* ongoing work; a Custom GPT is something you build to reuse or publish to the GPT Store. If five teammates need the Northwind brand assistant, a Custom GPT is the shareable version; a Project is your private one.

Connectors link ChatGPT to external sources like Google Drive, SharePoint, or GitHub so it can search them live. Where Project files are a fixed shelf you upload, Connectors are a live pipepipeAll active sales opportunities across the stages of the sales process, together with their combined potential value and probability of closing.View full definition → to a system of record.

The ChatGPT agent and scheduled tasks add autonomy: the agent can browse and act across steps to complete a task, and scheduled tasks let you say *"every Monday at 8am, summarize last week's Northwind sales file and email me the top three movers."*

When you outgrow the app: the APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →

When you need this repeatable and embedded in software, you move from the app to the OpenAI API. The current recommended entry point is the Responses API, which unifies model calls with built-in tools. (The older Chat Completions API still works and is widely supported.) For reliable downstream parsing, use structured outputs to force the model to return JSON that matches a schemaschemaA schema is the formal blueprint that defines how data is structured, named, typed, and related within a database, file, or message.View full definition → you define.

Here's the Northwind "flag declining SKUs" task as a small, schemaschemaA schema is the formal blueprint that defines how data is structured, named, typed, and related within a database, file, or message.View full definition →-constrained APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition → call:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1",
    input="From the sales summary, list SKUs with a week-over-week revenue drop over 15%.",
    text={
        "format": {
            "type": "json_schema",
            "name": "declining_skus",
            "schema": {
                "type": "object",
                "properties": {
                    "skus": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "sku": {"type": "string"},
                                "wow_change_pct": {"type": "number"},
                            },
                            "required": ["sku", "wow_change_pct"],
                            "additionalProperties": False,
                        },
                    }
                },
                "required": ["skus"],
                "additionalProperties": False,
            },
        }
    },
)

print(response.output_text)

That structured result drops straight into a dashboard or an email job, no manual parsing. From here, function calling lets the model trigger your own tools, and the Agents SDK orchestrates multi-step agents in code. Start at the OpenAI API docs when you cross this line.

The progression is clean: Projects and memory for personal, exploratory work; Custom GPTs and Connectors for shared, packaged assistants; the API and Agents SDK for production software.

Key Takeaways

• Use one Project per ongoing client or workstream. Load its files once and write scoped instructions; every chat inside inherits the brief, and the context stays isolated from your other work.
• Combine Project files with Advanced Data Analysis to run real Python against your uploaded data without re-uploading or re-promptingpromptingPrompt engineering is the practice of designing and refining text inputs to guide large language models toward accurate, relevant, and reliable outputs.View full definition → the brand voice each time.
• Let global memory hold durable personal defaults (your role, style, units) and let Project instructions hold client-specific context. Don't make memory do both.
• Reach for a Temporary Chat for sensitive or one-off work, and prune stale facts directly in Settings → Personalization → Memory instead of arguing with the model.
• Know when to leave the app: Custom GPTs and Connectors for sharing, the Responses API with structured outputs for production. Match the tool to whether the work is personal, shared, or programmatic.