One Dot Can Now Manage Several Computers: OpenAI dots Connects Multiple Local Machines, Builds Go to the Spare Box
On November 9, OpenAI let one dot connect to several local computers: one computer per thread, parallelism through more threads. Builds, tests, and bug reproduction go to the spare machine while the main machine stays free for coding. Before connecting, weigh the permissions: whole-machine access, no folder-level controls, and offline is not disconnected.

One dot can now manage several of your computers
On November 9, OpenAI's developer account @OpenAIDevs posted an update exactly one sentence long: you can now connect multiple local computers to the same dot and choose which one it uses for a task. The same day, the OpenAI Developer Community carried an announcement under the same title, with a short demo: a user types one sentence in the chat box, and the dot splits it into two tasks — “check the iOS build on my Mac Studio” and “fix the latest backend bugs in Linear using my Dev Box” — and runs them in parallel. The change itself is small, a single sentence, but it fills the gap users had complained about most since dots launched at the end of September: one dot could only be tied to one of your own computers.

Some background first, for anyone who has not used dots. A dot is the always-on agent OpenAI introduced at DevDay in late September, living inside ChatGPT; every dot has its own cloud computer and browser, and it keeps working after you shut your own machine. The launch itself was covered here on October 2 — that piece explained what a dot is. This piece is about the feature added on November 9: local computers went from “one” to “several.” Before the change, OpenAI's own help page said in plain words that you could connect only one personal computer at a time (the November 5 archived version still says so). After the change, that line is gone from the help page, replaced by a procedure for connecting more than one.
Connecting a machine is not complicated: three steps per computer, then repeat on the next one. First, open your dot's profile in the ChatGPT app on that computer. Second, under Computers, find the computer you are using and select Allow. Third, review the confirmation and select Allow access. The cloud computer stays connected throughout, with nothing to repeat; once your own computer is connected, the dot can use it no matter where you message it from — including from your phone. A second or third computer takes the same three steps, with no admin console involved.
But “several computers” does not mean “one task split across several computers.” OpenAI's documentation draws that line clearly: each thread uses one computer at a time. To run things in parallel, ask the dot to start a separate thread on each computer, each doing its own job. Switching computers does not move a task that is already running — a task stays on the machine it started on until it finishes. Get this limit straight before you start: you can have the dot run tests on your main machine while it does a build on a spare one, but you cannot cut one build in half and run half on each.
OpenAI's three examples are all aimed at developers. First, building an iOS app: ask the dot to test a change in Xcode on a second Mac and send back screenshots, while your own computer stays untouched. Second, reproducing a bug: ask the dot to run the same test on your laptop and on a machine with an older SDK, then compare the two results without changing your everyday setup. Third, testing a UI flow: have the dot click through a flow on a second computer and note where it breaks, keeping your own screen and cursor free while you work on the fix. The three examples share one trait: the spare machine does work that hogs a screen and takes time, but does not need you watching it.
Permissions, limits, and who can use it: look before you connect
Before connecting a computer, think through permissions, because they matter more than the connection steps. According to OpenAI's documentation, allowing a computer hands the dot that machine's local files, code, and apps; the docs describe only two settings, Allow access and Revoke access, with no finer per-folder or per-app controls in sight. Offline does not mean disconnected, either: an offline computer is simply unavailable, and the connection stays in place until you select Revoke access. One more trap is easy to miss: the dot's local-computer permission is separate from connecting a computer to Codex or enabling Work Sync — three independent things, and none of them grants the others on its own. Ask yourself one question before connecting: is this a computer you would hand to an agent? If the answer is no, do not connect it.
Once connected, the dot can do noticeably more. It can create local Work or Codex tasks on a connected computer and continue existing local Codex tasks; a task can be managed in the cloud while using files and tools on the connected machine, and opening the task shows where the work is actually happening. Plugins keep working too: connect Gmail and it can find email, connect Google Drive and it can read and update documents, connect GitHub and it can investigate an issue and prepare a pull request. Local skills need a connected computer to run. There are also hard stops: if a website blocks the dot's cloud browser, you can ask the dot to try your connected computer instead, but that starts a separate local task — it does not move the cloud browser's login over, and it does not guarantee that a particular local browser is supported.
Who can use it depends on plan and region. OpenAI lists Pro 100, Pro 200, and Pro 500 (18+, outside the EEA, UK, and Switzerland), Business Premium, and Enterprise, Edu, and Healthcare workspaces (admin preview; on by default from November 18 unless the workspace opts out). Every computer needs the ChatGPT app installed, online, and open while the dot uses it. Switch the machine off or close the app, and the dot just sees an Offline status — no error, and no automatic failover to another machine.
Once connected, day-to-day maintenance is three small habits. First, check the connected-computers list regularly: which machine is still in use, which one was sold or given away, which one was wiped and reinstalled — revoke access for anything in the list you no longer use, and do not leave a machine you have stopped using still connected to the dot. Second, mind the order when replacing a machine: revoke the old one first, then connect the new one — do not leave both connected at once, because a new machine will not take over the old one's unfinished tasks, and the wrong order only leaves one more machine connected. Third, the cloud computer needs no attention: it stays connected, needs no repeat steps and no periodic checks, and the dot finds it on its own. The cleaner the list, the easier it is to trace a problem: the task detail view shows which machine the work happened on, and matching it against the list points straight at the machine at fault.
Two judgments to close with. First, for anyone with a spare machine: the best use of this feature is splitting the “build box” from the “main machine” — long builds, long test runs, and UI flows that need clicking through go to the spare box, and the main machine stays free for writing code. That split was impossible when one dot could only bind one computer; now it works, at the price of one computer per thread, with parallelism coming from opening more threads. Second, for everyone: do not rush to connect your main machine. Whole-machine permission, no folder-level controls, and offline not meaning disconnected — those three together make connecting a computer a higher-trust decision than it looks. Connect the build box first, watch how reliably the dot works on it for two weeks, then decide about a second machine.
The timeline first: from late September to November 9
The change only makes sense on a timeline. Dots are the always-on agents OpenAI introduced at DevDay in late September, living inside ChatGPT with their own cloud computer and browser, still working after you shut your own machine. At launch, each dot got exactly one local computer — your own. Users started complaining quickly: the main machine is for writing code, while builds and tests hog it, and there was no way to send the dot to a second machine instead. OpenAI's help page still said in plain words, in its November 5 archived version, that you could connect only one personal computer at a time. On November 9, @OpenAIDevs posted the one-line update, the Developer Community published a matching announcement, and the help documentation switched to a multi-computer procedure the same day. Three sources, one story, a timeline that lines up: this was a formal feature launch, not a quiet documentation edit.
One thread, one computer: how the parallelism actually works
The rule for multiple computers comes down to one sentence: each thread uses one computer at a time. OpenAI's documentation draws the line clearly, and once you see it, the way to parallelize becomes obvious. To have a dot run tests on the main machine while doing a build on the spare, you give the dot one independent thread per computer, each doing its own work — two threads, two machines, no interference. Once a task starts, it stays on its machine: switching computers does not move a running task over, and changing machines means starting a new thread. The cloud computer stays connected throughout, no repeat steps needed, and it can keep doing the online work and coordinating results.
The official demo shows exactly this shape: the user says one sentence in the chat box, and the dot splits it into two tasks running in parallel — “Check the iOS build on Mac Studio” and “Fix backend bugs from Linear on the Dev Box.” Each task has its own thread and its own machine, and the task detail view shows which machine the work actually happened on. The reverse is equally true: splitting one build into two halves across two machines does not work, and switching machines halfway through a thread does not work either. The rule looks rigid, but it states one thing plainly: a dot's parallelism is “many threads, many machines,” not “one task, many machines.” Figure out which kind your work is before connecting computers, and you will not discover the split is wrong only after everything is wired up.
How to divide three machines: a division of labor to copy
With more than one computer, the division of labor can look like this. The main machine stays yours for writing code; the dot only does light work there — looking up a file, changing a small thing, running a short test — and never hogs the screen while you are working. The build box, say that Mac Studio, takes the long builds and long test runs from the dot: Xcode builds, full test suites, UI flows that need clicking through again and again, all sent over and left to run as long as they take. A third machine is kept for “old environments”: one with an older SDK installed, dedicated to reproducing bugs — run the same test suite on your laptop and on the old-SDK machine, put both results side by side, without touching the environment you use every day. The cloud computer keeps doing the online work: looking things up, running browser tasks, pulling the results together.
Three more rules sit alongside the table. First, long tasks go to the second machine and short interactions stay on the main one: builds and tests that run for a dozen minutes are cheapest on the spare box, while anything you need an answer from right now stays on the main machine. Second, do not hand over production builds first: try unimportant tasks for two weeks and see how reliably the dot works on the second machine — nobody has measured its stability, speed, or error rate yet, so do not make a production build the test subject. Third, every machine needs the ChatGPT app installed, online, and open for the dot to reach it; shut the machine down or close the app, and the dot only sees an “offline” state — no error, and no automatic switch to another machine. A task on the offline machine simply waits there until it comes back.
The cloud computer can count as a fourth machine in the table — and the one you never have to manage. It stays connected, needs no repeat steps, and handles the online work: looking things up, running browser tasks, pulling the results together. The reverse has its limits too: if a site blocks the dot's cloud browser, you can ask the dot to try from one of your connected computers instead, but that starts a separate local task — it does not carry the cloud browser's login state over, and no particular local browser is guaranteed to be supported. Keep the cloud-local split clear: online work goes through the cloud, work that needs local files and tools goes through a connected computer, and login states and files do not cross between the two — do not expect an account signed in on the cloud to still be signed in locally.
One real afternoon: the three official examples put together
Put the three official examples together into one afternoon, and the division of labor comes alive. On a Monday afternoon, you are changing code on your main machine and say to the dot: “Test this change, and fix that backend bug in Linear.” The dot splits it into two threads: one goes to the Mac Studio, tests your change in Xcode, and sends the screenshots back, while your own computer stays untouched; the other goes to the Dev Box and fixes the backend bug from its Linear description. Meanwhile, the cloud computer is still looking up a document for you. Three threads, three machines, each doing its own work, and your screen and mouse stay free the whole time so you can move on to the next bug. In the evening, open the task details and see where each piece of work actually happened: the build finished on the Mac Studio, the bug was fixed on the Dev Box, the document was found in the cloud.
The afternoon only works if the three machines keep to their own jobs and do not step on each other. The Mac Studio does builds and tests and nothing else; the Dev Box works only on its own bug-fix thread and does not touch the build; the cloud computer does only online work and never touches local files. If one machine goes offline, its thread simply waits there until it comes back — it does not switch to another machine on its own. That is also why every machine needs the ChatGPT app installed, online, and open. A division of labor on paper is one thing; running it is another. Try unimportant tasks for two weeks first, see how reliably the dot works on the second machine, and only then decide whether to hand over a production build.
A note for workspace admins: on by default from November 18
Enterprise, Edu, and Healthcare workspaces need to note one thing separately: connecting multiple computers arrives there as an admin preview, and it switches on by default from November 18 unless the workspace opts out. In other words, an admin who does nothing will find users able to connect several computers after that date. To switch it off, the workspace has to opt out in settings before then. To leave it on, the admin should still think it through first: an employee connecting a company computer hands that machine's local files, code, and apps to an agent, with no folder-level controls and no disconnect on going offline. In a company, the decision to connect a computer should not be made by one employee tapping Allow on a whim — admins are better off setting a rule before November 18: which computers may connect, which may not, and whether connecting needs to be reported first. A rule set late is hard to enforce once users are already connected.
One more honest note: no independent third party has tested this update yet. OpenAI's demo video is 17 seconds long, and the three examples are the company's own scenarios — nobody has measured how steady, how fast, or how error-prone a dot coordinating two machines actually is. The November 9 announcement, the Developer Community post, and the help documentation all agree, so the facts can be trusted; but “does it work well” will only be known once the first users have run it on their own machines. If you are among the first to try it, start with unimportant tasks, and do not hand it a production build on day one.
One line to separate this from the earlier dots piece published here: the October 2 article covered the launch itself — an always-on agent with its own cloud computer and browser, and which subscriptions it was open to. This article covers one specific capability added on November 9: connecting several local computers to the same dot and choosing a machine per task. They are not the same story; this one does not repeat what a dot is, only what was added, where its limits sit, and who can use it.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.