On this page
For a Dots to Codex context handoff, the coding task needs the right repository, current state, instructions and completion evidence. Connecting a computer makes local work possible; it does not automatically copy every conversation or move an existing task to a different machine.
Before delegating, identify the exact task and give it a compact, reviewable handoff. After it finishes, verify the result in the task's original environment. This guide follows OpenAI's Dots documentation checked October 15, 2026 and supplies a locally validated handoff record. It does not claim that a real task was transferred or completed during this guide's preparation.
Choose new work or an existing task
OpenAI's Tasks and memory guide distinguishes new local tasks, existing local Codex tasks, new cloud coding tasks and work the dot created. That choice determines where the work runs and what context needs to be supplied.
| Your intended handoff | Required setup | What to identify |
|---|---|---|
| New local Codex work | Computer connected to the dot, online with the app open | Repository and task brief |
| Continue local Codex work | The relevant connected computer | Exact existing task and requested change |
| New cloud coding work | Previously created Codex cloud environment | Environment, repository and setup |
| Follow a task the dot created | Its original computer or cloud environment | Original task and result to inspect |
The guide says that changing the dot's selected computer does not move an existing task. A new task has its own conversation and receives selected instructions and context for that work. It does not automatically inherit every conversation with the dot. Task and context boundaries
If you want to continue a known fix, name that task rather than asking for a generic new investigation. If you want independent work, describe the new result and its repository. The difference prevents a duplicate implementation from being mistaken for progress on the original task.
Make access and environment concrete
The Computers and apps guide describes the dot's cloud computer and the optional connection to your own computer. Local access requires the connected machine to be available. Browser sessions and connected service permissions are separate pieces of that setup.
For a repository task, record the checkout location, branch or revision, uncommitted changes and setup instructions. A path on one computer does not identify the same files on another. If the task uses a cloud environment, verify that the environment contains the intended repository and dependencies before assigning work.
Avoid treating “connected” as proof of readiness. The task may still need a package install, a service, an environment variable or access to test data. Ask the task to report these prerequisites before editing if they can change the implementation. Keep credentials out of the handoff text; point to the approved credential mechanism instead.
If there are existing local changes, name which files belong to the requested work and which should be preserved. For a separate checkout, explain the starting revision. The agent can then report a change against a known baseline instead of blending unrelated work into the result.
Supply a handoff that survives a new conversation
A useful handoff answers five questions: what result is needed, where the work runs, what state is current, what constraints apply and what proves completion. It can be short when those facts are precise.
Here is a synthetic example for a checkout defect:
The repository and task ID above are invented. Replace them with real identifiers and source links. A handoff that says “record the branch” still needs the receiver to report the branch it observed. Do not leave a synthetic path in an actual assignment.
Include the most relevant decision history, especially an approach already rejected and the reason it failed. Do not paste an entire conversation merely to maximize context. A few explicit constraints and evidence links are easier to validate than a long transcript with conflicting earlier instructions.
Validate the record before delegation
You can check that the handoff has its necessary fields locally, without creating a task. This validator checks completeness only; it does not verify access to the named repository.
The full example record passed this validator locally. A copy with no acceptance list was rejected. That result proves the handoff's local shape, not that a dot read it, created a task or ran any test.
Use the validator as a preparation check. The receiving task should still confirm the actual repository state, available setup and understood completion criteria. That readback closes the gap between sending a brief and knowing the correct execution environment received it.
Verify the receiver before trusting progress
Ask for a short first readback: task ID, execution computer or cloud environment, repository path, branch and commit, and any prerequisite blocker. Compare it with the assignment. If the task is looking at the wrong checkout, correct the target before it makes changes.
Keep coordination attached to the original task. A follow-up should identify which result or constraint changed. “Continue” is often too vague when multiple coding tasks are active. A precise instruction says which task to continue and what remaining acceptance item it should resolve.
Do not infer completion from a running indicator, a task summary or an accepted request. Open the task's result and inspect the diff, test evidence and demonstration. The documentation itself distinguishes a completed run from achieving or delivering the requested result. Reviewing task outcomes
For code work, check that the evidence belongs to the version being reviewed. A passing test from before the latest edit does not verify the latest diff. If the task changes its implementation after review, update the corresponding evidence and retain the outstanding checks explicitly.
Keep usage and notification decisions attached to the work
The Dots introduction says conversations with a dot do not count toward ChatGPT usage limits, while tasks started or managed in Codex or Work count toward those products' limits as usual. A handoff changes the work surface; it does not make the delegated task unmetered.
Define which results deserve a message. For an investigation, useful updates are a confirmed cause, a ready diff, a failed prerequisite or a decision you need to make. If the state has not changed, a repetitive update can distract without helping you review the work.
If you assign recurring work, keep its schedule and notification conditions explicit. A one-time context handoff does not automatically create a monitoring task. Review the saved schedule separately from the current coding task so stopping one is not mistaken for cancelling the other.
Build a handoff tracker with Atoms
Use Atoms to build a small tracker when a team delegates work across multiple tasks. Start with manually entered task links and readbacks. It is a review record, and does not require a native Dots or Codex connector.
Ask for task ID, target environment, repository, baseline, goal, acceptance items, receiver readback and result links. Keep statuses for prepared, assigned, receiver verified, implementation ready and accepted. Require evidence links for the acceptance transition rather than inferring it from a free-text summary.
In the preview, add the synthetic checkout record and leave receiver verification incomplete. Add a receiver readback and test result, then check that missing desktop evidence still blocks acceptance. Save and reload the record. For shared storage, consult the Atoms Cloud guide and test edit permissions for coordinator and reviewer roles.
Conclusion
A reliable Dots-to-Codex handoff names the task, environment, baseline and acceptance evidence. Verify the receiver's readback, then judge the actual result in its original environment. Build a handoff tracker in Atoms to keep those decisions visible when several tasks run at once.
Frequently asked questions
01Q1: Does connecting a computer copy every Codex conversation?
OpenAI's task guide says that computer access does not grant access to every existing conversation. Supply the relevant task identity and context explicitly.
02Q2: Does selecting another computer move the existing task?
The documented behavior says it does not. Continue the task in its original environment or use an explicitly supported move workflow with a verified result.
03Q3: Can a cloud coding task run while my computer is offline?
The guide supports that path through a previously created Codex cloud environment. Local tasks depend on the connected computer being available.
04Q4: Was an actual handoff performed for this guide?
No. The example record and its completeness validator were executed locally. Creating, receiving and completing a real task are separate live checks.
