OpenAI Dots: from background work to reviewed changes

A maintenance job rarely ends with finding the right command. Someone has to collect the request, inspect the repository, prepare a change, run the checks and bring the result back for review. OpenAI Dots aims to carry that work between conversations, reducing the need to restart the explanation each time.

Announced on September 29, 2026, OpenAI Dots is a persistent agent experience powered by GPT-6 Astra. Each dot has a cloud computer and can work through connected apps. OpenAI describes an ecosystem of more than 4,000 apps, but that is a catalog claim, not a guarantee that every integration supports your intended operation. The company is also previewing specialist dots for focused enterprise pilots. OpenAI’s launch announcement

For SRE and platform teams, the useful question is which part of an ongoing job can be handed over. Understanding the difference between background research and an authorized task provides a practical starting point.

How OpenAI Dots carries work forward

The product combines several things that are easy to confuse: a reasoning model, a working computer, connected tools and continuing context. The model interprets the request; the computer gives it somewhere to use software and prepare files; app connections provide the permitted operations. Continuing context helps it return to work without requiring a fresh briefing for every step.

OpenAI’s GPT-6 Astra model documentation describes support for complex reasoning, coding, computer use, research and document creation. Those model capabilities explain part of the product’s scope. They do not establish a reliability target for a particular Dots workflow, or prove that it can operate your internal service successfully.

A dot can create tasks in an existing Codex cloud environment. Its own cloud computer and that prepared coding environment serve different purposes: the former is the agent’s working space, while the latter supplies a configured place for repository work. Local computer access is optional and initially disabled. Setup starts on desktop web or the desktop app; mobile access follows setup. Getting started with your dot

This distinction matters for a maintenance pilot. A team with an established test environment can ask for a patch there, instead of giving the agent a general instruction to fix something somewhere. Our Codex Cloud environment explainer describes how prepared setup and individual task files remain separate.

Two kinds of work happen in the background

OpenAI’s safety description gives proactive research a specific meaning. It gathers information from permitted connections through read-only tools and saves private notes. Those research tools cannot directly send messages, change connected app content or control a browser or desktop. A follow-up action must pass the usual rules and checks. How OpenAI describes Dots safeguards

Meanwhile, work the user has already authorized can continue between conversations. Therefore, “it is running in the background” does not tell a reviewer whether the current task can make changes. Ask what task is running and what operations it was authorized to perform.

The distinction creates a useful division of labor. Research can gather the context for a maintenance request. An authorized task can prepare an inspectable change. A reviewer can then decide whether the change should enter the release process. Each stage has a different output, so a useful progress report should name that output rather than merely say “working” or “done.”

Follow one maintenance request through review

Consider a hypothetical pilot: a dot helps a platform team update an outdated dependency in a non-production repository. This is an illustrative workflow, not a report of a Dots deployment or measured productivity gain.

The engineer supplies the repository, the dependency to update, the target branch and the existing test command. The requested deliverable is a proposed patch with test output. The engineer retains merge and deployment decisions. This gives the dot useful work to complete without making release authority implicit in a broad maintenance goal.

The approval should name the change and the repository state being reviewed. If the branch changes before execution, reassess the patch against the new state. This applies the principle developed in our production-agent execution guide: a bounded action needs a defined target and current state. A Custom Rule can communicate the intended limit; a repository permission or protected-branch rule supplies a separate enforcement point.

Stage	Useful output	What the reviewer checks
Inspect	Dependency version, affected files and relevant issue links	The sources describe this repository and this request
Prepare	Patch against an identified base commit	The diff stays within the requested update
Test	Command, exit status and complete relevant results	The checks ran against the proposed patch
Review	Proposed change with unresolved failures stated	The result meets the team’s existing acceptance criteria

Suppose the dot reports a passing test, but the output shows the old dependency still installed. The command succeeded, yet the requested update remains unverified. The reviewer needs the installed version and the tested revision to decide whether the result is useful. This is why an agent’s completion message should point to inspectable work.

If an authorized write times out, inspect the destination before retrying it. For example, a pull-request creation request may have succeeded even though its response was lost. Check the repository for the intended branch and change before creating another request. Where the destination cannot establish the result, leave it unresolved and hand it to the repository owner.

If the team cannot verify the target state or enforce the permitted scope, keep the pilot at patch preparation. Additional autonomy is useful when it removes routine work the team can still assess, not when it makes the result harder to establish.

Review connections and retained information together

Dots shares plugin permissions with ChatGPT, ChatGPT Work and Codex. Existing connections therefore deserve review before an experiment begins. Custom Rules add action limits, while Auto-review checks certain planned actions against instructions and safety requirements. The documentation also distinguishes steps that can proceed from those requiring approval or human takeover. Dots privacy, security and safety FAQ

OpenAI describes sandboxed cloud workspaces and action-review controls outside the environment that the dot can modify. These are useful protections, but they address different problems. Sandboxing limits code and tool access; it does not make every permitted edit correct. Review still needs to establish whether the prepared change meets the request.

Disconnecting an app stops new access through that connection; it does not erase information already incorporated into the dot’s context. The FAQ says individual dot memories cannot currently be viewed or edited directly. Deleting a dot’s context and managing separately stored files or ChatGPT memories are different operations.

For a first workplace experiment, use an approved test repository and synthetic tickets. This lets the team evaluate the working process before bringing sensitive incident material into continuing context. If the proposed task needs data the organization cannot permit in that environment, choose a different task.

Check access and allowances before planning

OpenAI is rolling out Dots across Pro, Business Premium and Enterprise offerings, with plan, region and administrator conditions. The getting-started page excludes the EEA, Switzerland and UK from the initial Pro rollout and says Enterprise beta access requires administrator enablement. Account access can take several days.

At publication, the usage descriptions differ in emphasis. The launch announcement says conversations do not consume ChatGPT limits while delegated Codex and ChatGPT Work tasks count as usual. The help page describes a first-month allowance concession. Check the current terms shown for your account before budgeting recurring work; neither statement supports assuming unlimited delegated tasks.

Specialist dots are a separate enterprise-pilot proposition involving organization-managed identities and access. Do not assume the capabilities shown for those pilots are available in a personal dot.

Make the first trial easy to assess

Start with one maintenance request whose outcome a teammate already knows how to review. Keep the existing test and release criteria. Record the time spent preparing the task, reviewing the patch and correcting its mistakes, alongside the useful work completed. That comparison will be more informative than counting how long the agent stayed busy.

1. Choose a test repository and a small, explicit change.
2. Review existing app access and specify whether the output is a patch, draft or permitted write.
3. Require the base revision, proposed diff and test results with the handoff.
4. Check the resulting files or destination record independently.
5. Expand the next task only when the first result is useful and its limits remain clear.

Before assigning the job, complete this sentence: “I will accept this work when I can inspect ___ and verify ___.” Dots may handle much of the preparation between conversations. That sentence gives both the agent and its reviewer a concrete place to finish.