Prepare a checkable handoff from ChatGPT Work to Codex

Four events can produce two correct-looking reports. Group their timestamps by the date written in each row and you get three days. Convert each timestamp to UTC first and you get two. If a research conversation considered both approaches, the coding session needs to know which one you chose.

For a developer moving a task from ChatGPT Work to Codex, I want that choice in a file the next session can inspect, alongside the inputs and an expected result. Conversation context remains useful. A checked folder adds an exact answer to a different question: which decisions and data did this implementation use?

The complete example folder contains a synthetic task, a working Python implementation and a validator. Its command-line tests were run locally. The product sequence below follows OpenAI's documentation checked on September 26, 2026; it is a preparation procedure, not a report of an observed transfer between the products.

Give the next session a settled task

ChatGPT Work and Codex have overlapping capabilities. Work can research, use files and write code; Codex provides a development environment with views for changes and review. Pick the environment that suits the next step. Available modes and local access depend on the account, platform and workspace settings. OpenAI's product guide describes those choices.

The useful output of the research stage is a brief that separates settled decisions from suggestions. The example's brief specifies:

Produce daily event counts using the accepted UTC-day grouping in decisions.json. Read the input as CSV with exactly event_id and occurred_at columns. Convert each timestamp to UTC before choosing its date. Every timestamp must include a numeric offset or Z. Reject duplicate event IDs, missing values, malformed dates and unknown offsets (-00:00). Do not infer a time zone.

In a real Work conversation, ask it to prepare the brief from the decisions you actually made. Review the result against the conversation. A summary can turn “we could group locally” into “group locally” by dropping two words.

The folder makes the distinction machine-readable:

{
  "grouping": {"status": "accepted", "value": "utc_day"},
  "proposals": [
    {"id": "P1", "status": "proposed", "grouping": "source_day"}
  ]
}

This excerpt shows the relevant fields; the download includes the complete decision record. Its accepted labels are constructed for the tutorial. In your own task, record the real decision and who has authority to make it. Writing accepted into JSON grants no tool permission.

Make the example discriminate between the choices

The input is short enough to check by hand:

event_id,occurred_at
e1,2026-01-01T23:30:00-05:00
e2,2026-01-02T04:45:00Z
e3,2026-01-02T23:30:00-05:00
e4,2026-01-03T04:15:00Z

The first event is January 2 at 04:30 UTC. The third is January 3 at 04:30 UTC. Each therefore joins the following row's UTC day. The expected result is:

{
  "grouping": "utc_day",
  "counts": {"2026-01-02": 2, "2026-01-03": 2}
}

Taking the first ten characters of each timestamp would produce January 1: one event, January 2: two, January 3: one. Those counts still add up to four. Checking only the total would miss the disagreement.

Keep the expected result as a reviewed literal. Generating it with the same calculation you're testing can reproduce the same mistake on both sides of the comparison. For a larger task, select fixtures whose expected answers you can derive from a separate method or a trusted reference.

Package the inputs and retain their identity

The download has this layout:

handoff-example/
  handoff/
    brief.md
    decisions.json
    events.csv
    expected.json
    manifest.json
  trusted-manifest.sha256
  verify.py
  daily_counts.py
  test_handoff.py
  README.md

The manifest lists a SHA-256 digest for each of the four task inputs. The validator first compares the manifest itself with a separately supplied digest, then checks each input against the manifest. This detects a changed expected result as well as changed data.

For this exact example, the retained manifest digest is:

613bc45969e3a21436bc4e237a6886ff2244f97848de75905fc6d7583f409a0b

Keep that value outside the files the receiving task can edit. The digest file in the download is a convenience copy. If someone can change both a bundle and the value used to trust it, a successful comparison tells you little about the earlier bundle.

The manifest covers task inputs. Review the Python programs separately before running them. These checks do not authenticate an author, constrain arbitrary commands or prove that an AI session followed an instruction.

For a repository task, add the reviewed commit or diff and any dependency assumptions to the brief. A correct input folder paired with the wrong checkout can still lead to the wrong implementation. The context-file example develops the longer-lived project record; this folder captures one task's inputs and acceptance conditions.

Put the folder where Codex can read it

OpenAI documents local project folders as the files a desktop task can work with. In the project's menu, Edit project and Add folder connect a folder; Make primary chooses the starting folder for new chats. Codex's default project discovery uses that primary folder for Git context, instructions, skills and configuration. Adding a secondary folder does not give it the same automatic discovery behavior. OpenAI's projects documentation describes the distinction.

Prepare the handoff files in the intended local project folder, using the file or download controls available in your Work environment. Then select Codex, select that project and explicitly name the brief to read. OpenAI also documents attaching an existing ChatGPT chat to a Codex chat through Quick chat. That can supply useful discussion history; the checked files still specify which choice the implementation must satisfy.

Use a starting instruction like this, adjusted to your actual permissions:

Read handoff/brief.md and the decision record. Check the manifest against the digest I supplied separately. Explain the accepted grouping rule and calculate the expected counts from the four input rows. Then inspect the implementation and run its tests. If an input or decision differs, report the difference before changing the contract. Work only in this example folder; do not make external changes.

An arbitrary file does not become an automatically loaded instruction because it has a meaningful name. Point to it. If you also use AGENTS.md, follow the client's documented discovery rules and check the working directory. OpenAI's instruction-file guide explains the global and project layers.

Run the local checks

The example needs Python 3.10 or later and no extra packages. From the extracted folder, run:

python3 -B verify.py handoff --manifest-sha 613bc45969e3a21436bc4e237a6886ff2244f97848de75905fc6d7583f409a0b
python3 -B daily_counts.py handoff --manifest-sha 613bc45969e3a21436bc4e237a6886ff2244f97848de75905fc6d7583f409a0b > actual.json
python3 -B verify.py handoff --manifest-sha 613bc45969e3a21436bc4e237a6886ff2244f97848de75905fc6d7583f409a0b --result actual.json
python3 -B test_handoff.py

The first command checks the inputs. The producer then parses explicit offsets, converts each instant to UTC and groups its date. The third command compares the resulting JSON with the literal expected result and prints:

{"events": 4, "result_checked": true, "status": "PASS"}

All 16 tests passed in the local run. The producer was exercised with UTC, New York and Apia as the host time zone, and each output passed the validator. The suite also checks failures that would change the meaning of the task:

ChangeExpected rejection
Edit the CSV without updating its reviewed identityInput digest mismatch
Edit the expected result and regenerate the manifest while retaining the old digestManifest digest mismatch
Replace the accepted choice with a proposalRequired accepted decision missing
Supply local-day counts under a UTC labelResult differs from the literal expected counts
Remove an offset or repeat an event IDInvalid input

Other cases cover missing files, a symlink in place of an input, malformed JSON, duplicate JSON keys and a Boolean used as a count. A positive control changes an unaccepted proposal's wording and confirms that the UTC result stays the same. Several negative tests deliberately create a fresh test manifest so they can reach semantic validation; that test setup is separate from accepting a real changed task.

When the checks pass, retain the result with the input identity and reviewed code. When they fail, the failure identifies a decision to resolve: the input changed, the contract changed, or the implementation disagrees. Resolve that difference before replacing the expected answer.