OpenAI dots for developers: bug reports to tested PRs

This research library uses AI-assisted source research and drafting. Linked sources support product claims; analysis and proposed exercises are our interpretation. Unless an article documents a test and its results, do not read it as a hands-on review or an independently verified benchmark.

OpenAI dots are always-on agents in ChatGPT, announced at DevDay on 29 September 2026. Each dot runs on GPT-6 Astra with its own cloud computer and browser, keeps working when your laptop is closed, and can hand coding work to Codex (OpenAI launch post). For developers, the practical use is a dot that watches bug reports or user feedback and comes back with a fix you can review.

What OpenAI dots can do for developer work

A dot is a coordinator that stays on a job between conversations. You give it a responsibility, the sources it needs, and the decisions you want to keep. It decides when to pause, when to wake up, and when to ask you something.

OpenAI's own developer example is specific. A dot watches customer feedback, scopes small fixes, builds and tests them, and brings complete pull requests with attached videos. The dots documentation lists a similar job: connect the feedback source and the code project, then ask the dot to investigate a reported problem and prepare a fix for code review before merging.

Three capabilities matter for engineering work:

• Event monitoring: where a connected service supports it, you can ask a dot to investigate new bug reports in a Slack channel and prepare fixes for your review.
• Plugins: a dot uses the plugins enabled for your account, with their existing permissions. GitHub lets it investigate code and prepare changes.
• Background agents: a dot can split work across parallel agents that report back to it while you keep talking.

How dots relate to Codex and the Agents API

A dot does not replace Codex. It creates and steers Codex tasks. The tasks and memory guide describes four cases:

Each new task gets its own conversation and only the context your dot passes to it. Your dot's chats do not count toward ChatGPT usage limits. Tasks it starts in Work or Codex count toward those products' limits as usual.

The Agents API is a separate thing. It is OpenAI's public beta for building and running your own cloud agents on the Codex harness, and DevDay added computer use to it. OpenAI's material does not say dots are built on the Agents API. Treat dots as the agent you use in ChatGPT and the Agents API as the one you build into your own product.

Who can use dots today?

Dots are rolling out gradually, so an eligible account may not see them yet. The docs give this split:

You create a dot in the ChatGPT desktop app or a desktop browser. Mobile web is not supported, and the mobile app needs a supporting update. Microsoft Teams access is an invite-only alpha, and texting is listed as coming soon.

Set up a dot that turns Slack bug reports into pull requests

This is the workflow I would try first, because the output is a pull request you already know how to review.

1. Create a Codex cloud environment for the repository. In ChatGPT, start a new task, choose Work in > Cloud, then Select environment > Create environment. Pick the GitHub repository, let Codex install dependencies and test the setup, then select Publish.
2. Create your dot in the desktop app. Connect the GitHub plugin, and add Slack from the dot's profile with Add.
3. Add the dot to the bug channel and tell it what to watch. Adding it to a channel does not start monitoring on its own.
4. Ask it to confirm which events it can follow, and where it will report.
5. Open the dot's profile, select Activity, and review the first task before you widen the scope.

A starting instruction can look like this:

Watch #bugs for new bug reports about the web app. For each report,
reproduce it in the web-app Codex cloud environment, write
a failing test, fix it, and run the test suite. Open a draft pull
request with the test output. Do not merge, and do not reply in
#bugs without asking me. Confirm which events you can follow.

Only the owner can direct a dot in Slack. Messages from other people in the channel do not start work, although the dot can use them as context when you bring it into a thread.

Controls to set before a dot touches your repo

Built-in safeguards and automatic approval checks apply from the start. Before an action affects your accounts or shares information, auto-review checks it against your instructions, permissions, custom rules, and safety requirements. Some steps always stay with you, such as changing a password.

Custom rules live under Settings > Personalization > Custom rules. Each rule gets one of four behaviours:

Custom rules are instructions the dot tries to follow, and it can make mistakes. They do not grant or remove app access. Plugin permissions control app actions separately, so set the GitHub plugin's allowed actions as the real limit.

Put repository rules where Codex reads them: an AGENTS.md file with the test command, the files it must not touch, and the evidence a pull request needs. The dot passes instructions to the task, but the repo file is what every Codex task sees.

Stopping work has three separate controls. Pause stops the dot's current main task. Delegated tasks stop from Activity, and recurring work is cancelled in Scheduled. Stopping does not undo actions already completed.

Proactive research, the background reading a dot does on its own, uses read-only tools. It cannot send messages, change app content, or control a browser. Any follow-up it suggests goes through the same approvals.

For the review side, I pair this with the Delegate, Review, Own methodology: the dot delegates, a named person reviews the pull request, and that person owns the merge.

Try it this week on one low-risk repository and one Slack channel, and read every pull request the dot opens before you let it watch a second source.

Further reading

• Meet dots
• Control your dot
• Dots tasks and memory
• Introducing dots