Guide

Dots to Codex: A Context Handoff You Can Verify

Use the current provider contract and worked examples to prepare a reviewable decision. Build a saved review workbench with Atoms.

Start building for free
6 min readPublished
Dots to Codex title above a document handoff between two workstations.
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:

json
{
  "task_ref": "example-checkout-task",
  "environment": "local-connected-computer",
  "repository": "/projects/example-shop",
  "baseline": "record the actual branch and commit before editing",
  "goal": "Fix the mobile checkout submit button losing focus after validation.",
  "scope": "Checkout form and its existing validation flow.",
  "current_state": "Reproduction steps are attached to the original task.",
  "constraints": [
    "Preserve unrelated local changes.",
    "Keep desktop checkout behavior.",
    "Prepare the change and review evidence before deployment."
  ],
  "acceptance": [
    "Reproduce the reported mobile focus loss.",
    "Verify the corrected invalid and valid submit flows.",
    "Check desktop checkout with the same fields.",
    "Return the diff, test result and a short demonstration."
  ]
}

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.

python
def validate_handoff(record):
    required = {
        "task_ref", "environment", "repository", "baseline",
        "goal", "scope", "current_state", "constraints", "acceptance"
    }
    missing = required - set(record)
    if missing:
        raise ValueError("missing: " + ", ".join(sorted(missing)))
    for key in required - {"constraints", "acceptance"}:
        if not isinstance(record[key], str) or not record[key].strip():
            raise ValueError("empty field: " + key)
    for key in ("constraints", "acceptance"):
        values = record[key]
        if not isinstance(values, list) or not values:
            raise ValueError("nonempty list required: " + key)
        if any(not isinstance(v, str) or not v.strip() for v in values):
            raise ValueError("invalid list entry: " + key)
    return True

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.

A little more clarity

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.

Share this article
Made with Atoms

Your next idea starts here.

Turn what you learned into a working app or website.

Start building for free