ChatGPT Scheduled Tasks: Context, Memory, Files, and Tools

Give a ChatGPT Scheduled Task the facts it must use in its saved prompt, and name the source it should read at run time. For a fresh report each morning, use a standalone task. For work that should continue a discussion or follow an operation to completion, schedule it inside the existing chat. Memory can supply useful preferences and background, but it should not be the only place you keep an exact threshold, deadline, or required instruction.

That distinction is now explicit in OpenAI's scheduled task documentation: standalone web tasks start from the saved prompt; in-chat tasks return to the conversation with its existing context. Neither choice means the task receives every old chat, every file, or permission to use every connected account.

The practical goal is a task that can answer three questions on its next run: What am I checking? Where can I get the required information? What result should I produce? The examples below are illustrative prompts, not reports of tasks we ran. Product conditions and documentation were checked on October 7, 2026.

Choose a Fresh Run, an Ongoing Chat, or a Monitor

Choose the task arrangement before deciding what to put in Memory. A recurring job can require independent reports, continuity with a conversation, or comparison with its own previous results.

The first two choices follow OpenAI's standalone and in-chat guidance. The Help Center also describes monitoring tasks that use information from previous runs and stop when their condition is met. That is continuity within the monitoring job, not a promise of access to your entire account history.

For example, a weekly release digest should work even if you never discuss the vendor in another chat. Its saved prompt should identify the release page and the time window. An ongoing investigation into a particular release benefits from returning to the chat where you recorded the unresolved issue. A monitor should distinguish “the release page changed” from “the feature I need is now generally available.” Those are different alert conditions.

When you update an ongoing task, state the new decision directly: “The launch date is now November 2; replace October 26 in future checks.” Asking it to “use what we discussed” leaves the decisive fact harder to identify. In-chat context is useful, but explicit current instructions also help when a long conversation contains superseded plans.

Set the Cadence for the Task You Are Creating

The current documentation describes different scheduling scopes. The Help Center's regular timed tasks allow paid recurring tasks up to hourly; Free tasks run once per day in flexible windows. OpenAI's in-chat scheduling documentation separately supports minute-based intervals for active follow-up loops.

Use the controls and limits for your actual task type, plan, and workspace. An in-chat follow-up interval does not establish a universal minimum interval for every ChatGPT task, and a requested time is not a delivery guarantee. Include the time zone and an end date when either affects the job.

Put Exact Requirements in the Prompt, Preferences in Memory

Use Memory for information that helps personalize the result: your preferred writing style, customary units, or background relevant to your work. Put information that determines correctness in the task instructions or an accessible source.

For a renewal reminder, “I prefer short updates” can be a remembered preference. “Review the Acme renewal due November 20, alert at 80% usage, and read the usage report dated this week” belongs in the job itself. A remembered old threshold would change the outcome, so the task needs an identifiable current value.

OpenAI's memory documentation distinguishes ChatGPT web and Work memory from the separate local memory store used by Codex clients. A fact remembered during local coding work is not automatically an input to a ChatGPT web schedule. Work uses the memory settings available to the account and workspace.

The distinction also matters for delegated work. In OpenAI's Tasks and memory documentation for dots, context consists of selected messages, instructions, source material, and tool or delegated results. A newly assigned task gets relevant instructions and context; it does not automatically receive every conversation. A dot's saved notes are also separate from ChatGPT saved Memory and are not a complete transcript. Those are documented dot behaviors, not evidence that every classic timed task uses the same memory mechanism.

For your own task, keep a short, current brief with the facts that must survive: the subject, approved source, relevant baseline, decision rule, and desired result. Update that brief when the job changes. Avoid relying on a private file, password, or token being remembered; use the supported source and connection instead.

A Self-Contained Task Prompt You Can Adapt

Here is a fictional release-monitoring example. It uses public information and keeps the exact requirement in the prompt. Replace the bracketed fields with your actual source and requirement before using it.

Create a standalone weekly task for Mondays at 9:00 AM America/New_York.

Check the official release notes at [exact release-notes URL] for
[product name]. Cover the seven calendar days ending at the time of the run.

Our requirement: [exact feature] must be generally available for
[our plan and region]. A preview, waitlist, or announcement without
availability details does not satisfy this requirement.

Use the named official page and any official availability document it links
to. Do not replace an unreadable source with a guessed answer.

Return the report in ChatGPT:
- First say whether the requirement is satisfied, not satisfied, or unknown.
- Give relevant changes with their publication dates and direct links.
- Explain any plan or region restriction that changes the answer.
- If nothing relevant changed, say so briefly.

If the required page or lookup tool is unavailable, report which check
could not be completed. Do not send messages or change external accounts.
Confirm the saved instructions, schedule, and time zone.

This prompt gives each independent run a complete job. It also makes “unknown” different from “nothing changed”: one means the source could not settle the question; the other means the source was checked and no relevant update was found.

If you instead want a short-lived monitor in an existing chat, supply the current baseline and a stopping condition:

Continue this check in the current chat each weekday at 9:00 AM
America/New_York through November 2, 2026.

Baseline: the official page last checked in this chat describes
[feature] as a preview. Read [exact official URL] on each run.

Notify me only when the page confirms general availability for
[plan and region], the check fails, or you need a decision from me.
Include the supporting link and the changed availability wording.
Stop the monitor when the requirement is confirmed or the end date arrives.

The second prompt is meant to continue a particular investigation. Its baseline belongs to that investigation; it should not silently become a fact about unrelated products. OpenAI recommends trying the prompt in a regular chat and reviewing early runs before depending on the routine. A clear prompt helps define success; it does not prove that a future lookup or notification will succeed.

Can Scheduled Tasks Read Projects, Uploads, and Local Files?

A file must be available to the specific task through a supported route. Merely having it somewhere in ChatGPT, or naming its laptop path, does not establish access.

There is an important difference in the current official documentation:

• The Scheduled Tasks Help Center page explicitly says a task created in a Project cannot access that Project's uploaded or project files.
• The Learn documentation for scheduled tasks on the web says tasks can use uploaded files and connected tools available to the chat, and recommends keeping required material in an accessible project, upload, or connected service.

These statements do not support an unconditional answer that all Project files work—or that no scheduled task can use any upload. For a task created in a Project, do not rely on its file store; for a web/Work task, check which upload or connected source is available to that chat. Require the output to name the document and version or date it actually read. If that access fails, a useful alternative is to place the necessary non-sensitive excerpt directly in the prompt, or use an authorized connected source that the task can read.

An upload is a supplied copy, so a weekly job using it also needs a plan for freshness. “Read the latest budget” is incomplete if the task only has last month's attached file. Name a stable source it can retrieve, or replace the supplied copy when its contents change. Do not solve this by putting private documents on a public URL.

For live local files, the execution location matters. Desktop project schedules require the computer to be on, the app running, and the project available on disk. Work Cloud can separately call approved tools on an online, connected computer when Local computer access with Work Cloud is enabled for eligible new tasks, with the required workspace permissions, sync, and supported client. Existing tasks retain their original mode; cloud execution does not automatically inherit laptop files, apps, browser sessions, or network access.

Use the local file access guide for Work, Codex, and Claude Code when the next step is choosing between an attachment, an approved live local task, and a repository workflow. That setup decision comes before asking a future run to read a folder.

Which Tools and Apps Can a Future Run Use?

Use the tools available to the task's chat and execution environment, with the connection and source permissions needed for the job. The scheduled task documentation describes connected tools, skills, and plugins; it does not grant every integration or action to every account.

For a connected-source briefing, name the account or source you intend to read, the relevant folder or channel, the time window, and the allowed action. “Summarize the connected planning channel's new messages in ChatGPT” is different from “send the summary to everyone in the channel.” The latter requires permission to disclose the content and perform that external action.

OpenAI's Work connection documentation separates app availability from an authorized connection. That connection may belong to an individual, a shared account, or an agent-owned account, and its source permissions can differ from the requester's. Workspace rules and app settings may require approval or restrict actions. Some actions can run without individual confirmation; others can pause for review. Do not assume every app is read-only or that every unattended write is allowed.

For each required lookup, ask the report to include a source identifier and the relevant retrieved date or record. A fluent summary alone does not show that it used the intended inbox, repository, or document. For a permitted external action, also inspect the destination's result: a prepared draft is different from a delivered message.

Supported App Events Are Available; Arbitrary Webhooks Are a Different Job

Current event-triggered task documentation supports eligible Gmail incoming messages, Slack channel messages, and GitHub pull request activity on web and mobile. Slack requires the relevant channel access and @ChatGPT membership; GitHub requires access to the repository. The Help Center lists Plus, Pro, Business, Enterprise, and Edu among eligible plans, subject to workspace availability; Free and Go do not support app event triggers. The desktop app can display existing event tasks, but cannot create or edit their trigger conditions.

The saved prompt still determines what to do with the event. Multiple matching events can be combined into a run, and a task cannot combine event triggers with a time-based schedule. The documented app events are not a general HTTP webhook endpoint for any outside service. Use a workflow or backend integration when you need arbitrary incoming payloads, queue processing, or guaranteed retry and delivery behavior.

Shared Task Copies Need Their Own Context and Access

Sharing a task is a way to distribute a routine, not a way to transfer your private working environment. The Help Center's sharing guidance says the shared snapshot carries its title, instructions, schedule and original time zone, plus eligible settings such as mode or model. It excludes the creator's conversation, prior results, saved Memory, custom instructions, files, app data, and credentials.

The recipient creates an independent copy in a new conversation with their own account, app connections, and permissions. Later edits to your original do not automatically update that copy. Instructions such as “use the document above” or “use my connected Gmail account” therefore need replacement before the copied job is useful.

Write portable instructions with explicit inputs: “Use the release URL supplied below” or “read the planning channel you authorize for this task.” Review the saved time zone as well: the original schedule may run at a different local time for the recipient.

When ChatGPT Scheduled Tasks Are Not Running—or Use the Wrong Context

Open Scheduled and inspect the task's status and recent runs before changing its prompt. Separate a missing run, an incomplete lookup, an incorrect answer, and a missing notification. They call for different fixes.

Deleting a task's associated chat pauses the task; deleting the task does not delete its conversation. A monitoring job can also finish when its end condition is met. These behaviors are documented in the Help Center. Stopping current work and canceling its recurring schedule are separate actions in dot controls.

If you see “you've reached your limit of 5 active tasks,” five is currently the Plus limit, not a universal ChatGPT limit. The Help Center lists three for Free/Go, five for Plus, ten for Business/Edu, and fifteen for Pro/Enterprise. Check the actual plan and active tasks before deciding whether to pause an unused job. An unfamiliar field such as notifications_enabled: false in an old example is not, by itself, evidence that a scheduled run failed.

After any correction, judge the next result against the job: did it use the right source, cover the requested period, apply the current rule, and produce the requested output? A completed status or notification proves less than that full result.

FAQ

Do ChatGPT Scheduled Tasks Remember Previous Chats?

An in-chat scheduled task uses that chat's existing context; a standalone web task starts from its saved prompt. Neither is documented as receiving every previous conversation. Put required facts in the saved instructions even when continuing a chat. See OpenAI's task guidance.

Can a Scheduled Task Use Memory?

Memory can provide relevant supporting context where the account and task environment allow it. Use explicit instructions or an accessible source for exact requirements. ChatGPT web/Work Memory and local Codex memories are separate stores, as explained in OpenAI's memory documentation.

Can Scheduled Tasks Access Project Files?

The Help Center excludes uploaded and project files for tasks created in a Project. Learn's web task documentation separately describes available uploads and accessible sources. Identify the specific task and file route rather than assuming all Project files are inherited.

Can a Task Run When a Gmail Message or GitHub PR Arrives?

Yes, supported app events can trigger tasks on eligible plans and workspaces, using authorized Gmail, Slack, or GitHub connections. This differs from arbitrary webhook input, and matching events may be combined into one run. See supported event triggers.

Does a Shared Task Include My Memory and Connected Apps?

No. A shared snapshot excludes Memory, conversation history, files, app data, and credentials. The recipient needs their own inputs, connections, and permissions, and creates an independent copy. See the task sharing guidance.

Can I Use a Custom GPT or Voice Chat as the Task?

The current Scheduled Tasks Help Center page lists GPTs and voice chats as unsupported. Put the necessary behavior in the supported task's instructions or available skill rather than relying on a custom GPT's configuration being carried over.