Opens in a new tab
Explainer

Resume the scheduled report from the work already finished

In brief

A timeout can leave a correct file and an uncertain announcement. Keep one reporting identity, inspect both destinations and continue only the unfinished step.

5 min read

Is this the right starting point?
Before you read
Basic familiarity with a scheduled workflow that reads information, saves a file and sends a notification.
What you will take away
Define an execution/recovery contract that preserves one report’s identity and reconciles file and notification outcomes separately.
Sources
A clay figure rests one hand beneath her chin between a blue holder containing a lilac sheet and a counter with another lilac sheet, a yellow lamp and an empty wooden cubby.
On this page4 sections

The 09:00 reliability report times out. A file is sitting in the folder. There may also be a message in the channel. Retry looks like the obvious next button, unless it creates a second report and announces it twice.

This hypothetical job reads incident records, calculates the preceding seven complete days in Python, saves a report and posts its link. The team is owed one correct report for one period, delivered once. Before repeating anything, find out which parts already happened.

Keep the reporting period fixed across attempts

Fix the reporting interval and timezone before retrieving records. Otherwise a retry across midnight can quietly become tomorrow’s report. An identity such as reliability:2026-10-20 can name the report ending October 20 in the agreed zone. Store the actual start and end as well; nobody should have to guess the date convention.

A 09:20 retry still owes the 09:00 report. Tomorrow’s run owes a different one. Give the report one identity and its attempts separate identities, so another execution does not masquerade as another reporting day.

Job componentWhat to retainWhat recovery needs to know
InputReport identity, fixed period, timezone and source snapshot or retrieval time.A retry must use the intended period; changed input must remain visible.
Calculation and writingRequired Python calculation, permitted incident source and any model requirement that affects acceptance.Missing dependencies can stop preparation before an external write.
DeliveryApproved folder and channel, with file and message identifiers when available.The operator can inspect the places the job was authorized to change.
RecoveryAttempt identifier, deadline, last established stage and unresolved outcome.The next attempt can continue the unfinished step.

These details form an execution contract: what the job needs, may change and must establish before it is finished. Keep fields that answer recovery questions. Credential role and destination can help; secret values do not belong. A source version can help too. Retrieval time records when collection occurred, but cannot recreate a source that changed during collection.

Make sure this runtime can produce this report

The report cannot reach its folder until something calculates the week’s figures. Here Python needs incident records, then delivery needs folder and channel access. Selecting a model on a setup screen cannot supply a missing tool or source. Model identity also matters when it affects acceptance or cost. The scheduled runtime must obtain what this job actually requires.

A user report about ChatGPT scheduling described model and environment differences across ChatGPT scheduling surfaces. It is one user’s experience, not a product-wide guarantee. For our constructed job, it suggests a practical question: will the place running the schedule have the means that were available when it was set up?

OpenAI’s training material and scheduled-task walkthrough recommend trying work in ordinary chat and reviewing completed runs. A rehearsal here could open the incident source, calculate the figures and save a draft in the intended folder. That gives the team something tangible to inspect. It does not guarantee tomorrow’s 09:00 result: input, permissions and availability can change, so that run needs its own check.

For an SDK-based job, OpenAI’s model guidance addresses explicit production model selection, and the API reference discusses pinned versions and evaluations. Those are API practices. They do not establish that a ChatGPT task surface exposes the same controls. Describing the same report does not make the interfaces interchangeable.

After the run, compare the intended job with the runtime, calculation and tools that actually produced it. Record resolved model identity where exposed and relevant. If a required dependency cannot be guaranteed or revealed, narrow the promise (perhaps to a draft for review) or choose an interface that can provide it. A plausible file produced by an unexplained substitute is not the same completed job.

Recovery follows one reporting period through a verified file and matching channel message. A demonstrably absent message permits notification-only continuation; an unknown outcome needs reconciliation.
A timeout does not settle either write. Inspect the saved report and channel independently, using lookup and retry guarantees supported by each destination.

Treat the file and its announcement as separate writes

To the reader, saving a report and announcing it feel like one delivery. To recovery code, they are two writes. Retain the file and message identifiers returned by each destination. A failed announcement is not a reason to recreate a verified file.

A timeout says the outcome is uncertain, not that nothing happened. Inspect the destinations. Where an API supports an idempotency key, repeat the same operation with the same key within its documented guarantee. AWS explains how a caller-provided identity distinguishes a retry from new intent.

A predictable filename helps locate the report, but cannot prevent two workers from searching, finding nothing and both writing. That requires destination-enforced uniqueness or a suitable idempotent operation, with its scope and retention limits understood.

The channel needs a separate check. Finding the matching message establishes more than an empty search: delayed or incomplete listings may conceal a message already sent. If the outcome remains uncertain, retain “notification unknown.” Sending again is a poor way to discover the first send succeeded.

Resume the step whose outcome is known

Open the report and check the period, source context and calculation, not just its filename. Preserve it if correct while resolving the delivery state:

State establishedNext action for the same report
Verified report and matching message are present.Record both identifiers and accept delivery.
Verified report is present; the message is established absent through a supported mechanism.Continue only the notification step under its retry policy.
Verified report is present; message outcome cannot be settled.Retain the report and hold notification as unknown for review.
The file is absent, incomplete or for the wrong period.Resolve that preparation or write outcome before announcing a report.

The incident-response evaluation guide distinguishes an agent’s claim from independent outcome evidence. For a worker you operate, the supervised-worker guide covers host-level timeout, cancellation and ownership.

Keep this machinery proportionate. A reminder has neither this report’s calculation dependency nor two destinations that can disagree, so it needs less. Before relying on a schedule, inspect the actual interface and a completed run; capabilities change.

Now the timeout can lead to one small remaining action. Preserve the verified file, accept delivery when the matching message is present or leave a precisely named notification uncertainty for review. The schedule can continue without needlessly repeating the morning’s work.

Sources & context

Sources linked in this article. Read alongside the author’s analysis; a citation does not independently verify a publisher’s claims.

Report an error or outdated detail

More on OpenAI

All OpenAI coverage

Keep reading

Where to go next