Most AI assistants behave like vending machines. You type a request, get an answer, and nothing else happens until you come back with another prompt. Follow-ups, reminders, and the question 'did that ever get done?' stay your job.
OpenAI released dots at DevDay on September 29, 2026. A dot is an always-on agent inside ChatGPT. It runs on GPT-6 Astra, gets its own cloud computer and browser, and keeps working between conversations. It can inspect your connected apps, delegate long-running work, and message you when something needs a decision. At first glance that overlaps with other agentic products, but its real value is as a chief of staff: something that reads Gmail, Google Calendar, and project threads, notices what slipped, and chases the tasks you hand it until they are actually finished.
This guide builds that setup with one running example: a solo developer with a personal dashboard app, a hobby game, a newsletter due on Tuesday, and a week on the road. Plan names, limits, and menu labels come from OpenAI's docs and were checked on October 29, 2026.
Summary
A dot is a coordinator, not an errand runner. It lives inside ChatGPT next to your memory, plugins, ChatGPT Work tasks, and Codex threads, and it hands real work off to those specialized tools. It works in two directions. Proactively, it reads your connected apps in read-only mode and tells you what slipped. Reactively, you dump a list on one call and it starts and tracks each task. Custom rules decide what it may do alone, and a short 'message me only when something matters' instruction removes most of the noise.
Access is narrow for now. Personal accounts need Pro, starting at $100 per month. Business Premium and Enterprise are rolling out, and personal Pro excludes the EEA, UK, and Switzerland. Work and Codex tasks started by a dot count toward those product limits, while conversations with the dot itself do not count toward ChatGPT usage limits.
How a dot differs from ChatGPT Work and Codex
A dot is a persistent agent with three things a normal chat does not have.
First, it has its own cloud computer and browser. That means it can keep working while your laptop is shut. It can open pages, run tools, and perform research independently of your local machine.
Second, it has memory beyond the current chat. It can use relevant ChatGPT memory, search across your past conversations, and maintain its own notes about your preferences, decisions, and ongoing work. Those notes follow it across the ChatGPT app, Slack, Microsoft Teams, and voice calls.
Third, it can pause and wake itself up. A follow-up check does not need a fixed schedule. The dot can sleep and then resume when it needs to verify something, chase a task, or ask you a question.
It reaches your apps through ChatGPT plugins. OpenAI listed more than 4,000 plugins at launch, covering Gmail, Google Drive, GitHub, and many other services. If you connect your computer through the ChatGPT desktop app, the dot can also use local files, code, and apps on that machine, and it can continue existing local Codex tasks.
The key architectural point is what a dot does with big jobs: it does not do them in its own chat. The docs split the work clearly:
| Tool | What it is for |
|---|---|
| Chat | Answers, explanations, ideas, drafts |
| ChatGPT Work | Delegated tasks like research, analysis, or file creation, now or on a schedule |
| OpenAI Codex | Building, debugging, testing, and reviewing software |
| Your dot | Ongoing responsibilities, next steps as things change, follow-ups between conversations |
Because a dot delegates, it can split big jobs across background agents that run in parallel. Since an October 9 update, it can also start Codex work and follow up on existing Codex threads. That is the entire case for the dot as a coordinator.
On paper, Meta's Muse and xAI's Grok Bot compete with the same idea. Meta's Muse is cheaper for shopping, travel bookings, and forms. xAI's Grok Bot runs teams of always-on bots inside work tools. Neither sits on top of the threads, memory, plugins, and Codex tasks you already have in ChatGPT. If you treat a dot like a one-off errand tool, you ignore the context it is standing next to. Used as a coordinator, it feels different.
How the alternatives compare
Users who follow AI launches will notice that dots are not the only always-on assistant. The comparison depends on where your work already lives.
Meta's Muse is good at consumer-facing errands. It can handle shopping, travel bookings, and forms, and it has a free tier in the US. It is designed to be cheap and approachable, but it is not built around software project context like existing Codex threads or a personal Obsidian vault.
xAI's Grok Bot is aimed at running teams of bots inside your work tools. It can complete tasks across Slack, email, and documents, and it feels like a multi-agent workspace. The tradeoff is that it does not share ChatGPT's memory, plugin ecosystem, or Codex task history.
OpenAI's dot is different because it coordinates the products you already use. It is less independent, but it has more relevant context. In practical terms, a dot can say 'I found a blocking issue in your existing Codex thread, and the research you asked for is done. Here is what I need you to decide.' That mix of delegation and follow-up is hard to replicate in a generic bot team.
| Product | Best at | Limitation |
|---|---|---|
| Meta's Muse | Shopping, travel bookings, forms | Less useful for software project follow-up |
| xAI's Grok Bot | Running teams of bots in work tools | Does not share ChatGPT memory and Codex threads |
| OpenAI dot | Coordinating ChatGPT Work and Codex | Expensive, one per account, regional limits |
What you need before you start
Dots are not available on free plans. The current plan list is short:
- Personal accounts need Pro 100, Pro 200, or Pro 500, starting at $100 per month.
- You must be over 18.
- Personal Pro excludes the European Economic Area, the United Kingdom, and Switzerland.
- Business Premium is rolling out worldwide.
- Enterprise is rolling out, but a workspace admin must enable dots first.
- Free, Go, and Plus are not on the list.
The rollout is gradual, so even an eligible account may not see dots immediately. On October 28, a community forum post announced that dots are available in the EU on Business and Enterprise plans, with consumer plans coming very soon. That was confirmed by OpenAI.
Your first dot is included in the plan. OpenAI says you will be able to add more dots later, but pricing for additional dots has not been announced. Conversations with your dot do not count toward ChatGPT usage limits. Tasks that the dot starts in ChatGPT Work or Codex do count toward those products' limits. Plans also include an allowance for deeper dot work, with extended limits for the first month after launch. OpenAI has not published hard numbers for that allowance, so keep an eye on usage once the first month passes.
Set up your dot
Setup takes only a few minutes, but you need to connect the apps you want the dot to watch. In the running example, that means Gmail, Google Calendar, Google Drive, GitHub, and Slack, plus the laptop where the dashboard app, the game, and the Obsidian vault live.
Follow these steps.
Create the dot. Open dots in the ChatGPT mobile app, desktop app, or a desktop browser. Mobile web is not supported. Follow the introduction flow and give your dot a name and a look. Its handle starts as @yourname-dot, and naming the dot updates it. For example, a dot named Alfred becomes @yourname-alfred.
Connect plugins. Add plugins for the apps you want it to use, such as email, calendar, and files. Each plugin works with its connected account and uses permissions that already exist on that account, so review those permissions while you are in the flow. You can skip this step and add plugins later.
Connect your computer. In the ChatGPT app on the computer you want to connect, open the dot's profile, find 'Your computer' under Computers, select 'Allow access', and confirm. The dot can then use local files, code, and Codex tasks on that machine. This only works while the machine is online and the ChatGPT app is open. Only one personal computer can be connected at a time. 'Revoke access' removes it.
Add a channel. On the dot's profile, 'Add' shows contact methods available to you, such as Slack and Microsoft Teams. Texting over iMessage or RCS is rolling out in beta to Pro users in the US. Channels are only a way to talk to the dot. Apps and your computer are connected separately.
After that, write rules before you let the dot near your inbox. That rule-writing step is easy to skip, but it is the most important part of the setup.
Write custom rules before you hand over your inbox
Before a dot can take an action that affects your accounts or shares information, an automatic review checks that action against your instructions, permissions, custom rules, and safety requirements. The action then proceeds, waits for approval, or includes a step you must do yourself. OpenAI uses changing a password as the example of something a dot will always hand off to you.
Custom rules are how you tune that middle ground. On desktop and web, they live under Settings > Personalization > Custom rules in the Permissions section. On iOS and Android, open the sidebar and select Customize > Custom rules. Each rule is a plain-language description of an action plus one of four handling options.
A starting set for a chief of staff might look like this:
| Action | Handling |
|---|---|
| Send an email or Slack message to anyone other than me | Ask before taking action |
| Accept, decline, or move calendar events | Take action when you say so |
| Write drafts, update notes, start or continue Codex tasks | Take action without asking |
| Pay, refund, or change a login | Hand off to you |
Two details are easy to miss. Asking for draft replies does not authorize sending them, so 'draft replies to these three emails' leaves the drafts in a draft state. Plugin permissions are a separate layer. From the rules page, open 'Plugins' to see Plugin permissions, and remember that a custom rule never grants access to an app or computer. You have to connect those in the setup stage first.
Finding the right autonomy level
The four handling options are not equally useful for every action. For a chief of staff role, you want low-risk tasks fully automatic and high-risk tasks explicitly approved. Start with the most restrictive option for anything that touches another person or costs money. For notes, drafts, and Codex work, 'Take action without asking' is reasonable if the dot has a clear finish line.
One useful pattern is to separate 'read' from 'write'. The dot can read your inbox freely, but any draft that goes out should require approval unless you explicitly name the recipient and say send. Another pattern is 'propose, then act': ask the dot to prepare an action and wait for your go signal. The 'Take action when you say so' mode is built for that. The dot does the prep work and then waits. When you are on the road, this reduces back and forth while keeping a human in the loop.
The proactive half: what it finds without being asked
Right after setup, a dot introduces itself and uses the context and connected apps to look for places it can help. No prompt is required. For the traveling developer in our example, a first pass might return three things:
- A hotel folio that does not match the booked rate, worth sorting out before checkout.
- A sponsor email that has sat unanswered for two weeks.
- A recording session planned for tomorrow that depends on details nobody has confirmed yet.
This research is read-only by design. The tools the dot uses for research cannot send messages, change app content, or control your browser or computer. Background agents report what they find to the main dot, which turns it into a suggestion or a question. Any follow-up action goes through the same review and rules we described above.
The other half of 'proactive' is follow-up. Because a dot pauses and wakes on its own, it keeps checking on things after a conversation ends. That cuts both ways. Suppose you ask the dot to chase a newsletter sponsor for an unpaid invoice. You go back and forth on wording, it sends the message, and half an hour later the dot independently looks at the payment side and tells you the money arrived last week. Useful, and a little embarrasing. The fix is to put the check in the original instruction instead of relying on follow-up: 'Before chasing any invoice, confirm it is still unpaid.'
Research runs read-only. Only the final step acts, and only through the automatic review plus your custom rules.
The reactive half: hand it a whole to-do list on one call
The fastest way to load work onto a dot is to call it. Open the dot's conversation and select the phone button, or press 'Call' on its profile in the desktop app. The screen actually rings like a phone call, which feels like a gimmick the first time. Past that, it is the quickest way to empty your head. You can type while you talk, and ending the call does not stop the work you assigned. Dot-initiated calls are planned for after launch.
Here is a realistic list that our developer dumps in one call:
- Research the topic for Tuesday's newsletter and put a full outline into the existing note in the Obsidian vault, complete enough to turn into a draft without missing a key point.
- In the existing Codex thread for the dashboard app, which already pulls Apple Reminders, calendar events, and Obsidian tasks onto one board, make a double-click on a task open a basic Markdown editor inside the app, save edits back to the Obsidian note, and keep an 'Open in Obsidian' button for anything heavier.
- In the game's Codex thread, fix the player getting stuck between walking and climbing on steep slopes, and make god mode give unlimited arrows and faster movement for playtesting.
The dot reads the plan back, then fans it out. The research goes to a background agent or a ChatGPT Work task, and the outline lands in the vault through the connected computer. The two coding jobs continue existing local Codex tasks on that computer, which means the computer must stay online with ChatGPT open. New coding work can instead run in a Codex cloud environment that you have already set up, with the laptop off. The dot can open each job as its own visible thread, and Activity on the dot's profile in the desktop app shows each task's progress, files, results, and requests for input.
This is where the dot beats opening three threads yourself. It owns the follow-through. OpenAI's docs say plainly that a completed run does not by itself confirm that the requested result was achieved or delivered, so give it a finish line along with the task. 'Done means the editor saves back to the note and someone has played the god-mode build' is a bar the dot can check, chase, and report on. When it needs a decision or approval, it messages you, and with the ChatGPT app on your phone that arrives as a push notification you can answer from anywhere.
Making delegation reliable
When you hand a dot three tasks in one call, small ambiguities become expensive. The dot can split work, but it cannot read your mind. Use these patterns to reduce wrong results.
Define done in observable terms. Instead of 'improve the dashboard,' say 'double-clicking a task opens a Markdown editor, edits save back to the Obsidian note, and an Open in Obsidian button appears.' The dot can verify that behavior with its cloud browser and report the result.
Ask for one summary message. A good instruction is 'When everything is finished, send me a single message with the file paths and the test results.' This prevents a stream of small updates.
Ask for sources on research. If the newsletter outline has claims or numbers, tell the dot to list sources. OpenAI itself asks you to review important results, so sources should be part of the artifact, not a separate request.
Set a deadline for each job. 'If the Codex thread is not finished by Friday, tell me what is blocking.' This turns an open-ended background job into a bounded one and gives the dot a reason to wake you.
Separate new work from existing Codex threads. When you mention 'the existing Codex thread for the dashboard app,' the dot knows to continue that thread. If you just say 'fix the dashboard,' it may start a new thread and miss context. Name the thread and the file path when it matters.
Use checkpoints. For longer jobs, ask the dot to pause after each milestone and report before starting the next step. That keeps the human loop short and avoids a large batch of wrong work.
A day in the life with a dot
To make this concrete, imagine the first morning on the road. The dot has already checked the hotel folio and flagged a rate mismatch. It also noticed that the sponsor email is still unanswered. While you are having coffee, the dot sends one message: 'The hotel folio is wrong, and the sponsor email is two weeks old. Do you want me to draft replies to both?' That is the proactive half working.
You call the dot and dump the newsletter and coding tasks on it. It starts the research in the background, writes the outline to the Obsidian vault, opens a Codex thread for the dashboard editor, and starts another for the climbing bug. At lunch, the dot reports that the editor task hit a build error and asks whether to try a different approach. You approve. By evening, the outline is in the vault, the dashboard editor is running locally, and the climbing bug is fixed in the god-mode build. The follow-up loop happened without you copying and pasting context between tabs.
The dot's own activity feed doubles as an audit log. You can see which background agent handled the research, which Codex thread changed, and which files were written. That transparency matters when you are trusting an agent with real work.
Make it quieter, and more useful
Out of the box, a dot can be chatty. Connect Gmail and it may start telling you about new emails all day, which is noise when your phone already notifies you about every email you recieve. Tell it, in plain words, what you do not want and what you do: 'Do not tell me about new emails. Message me only if a deadline is at risk or you need a decision.' The dot keeps preferences like that in its notes, and you can ask it to confirm what it saved.
A few more instructions pay off quickly:
- Route by kind. Keep routine progress in ChatGPT and send decisions to Slack. The dot picks the channel based on what you have told it.
- Make check-ins explicit. Recurring work needs a clear schedule. Use a format like 'Every weekday at 8 AM IST for the next four weeks, check my inbox and calendar and send me in Slack only what needs a decision today. Confirm the schedule.' You can later review or cancel it under Scheduled.
- Tell the dot directly when priorities change. Its notes are separate from ChatGPT's saved memory. Changing a saved-memory setting does not necessarily change the notes the dot has already made.
Stopping work happens in three places. Pause stops the dot's current main task, but it does not stop every delegated task or cancel future scheduled runs. To stop a delegated task, open it in Activity. To end a recurring one, disable or delete it in Scheduled. None of these undo actions that have already completed.
Where dots still fall short
Price and region come first. One hundred dollars a month for one agent is a lot if you only want help with email. Meta's Muse has a free tier in the US for errands. Personal Pro accounts in the EEA, UK, and Switzerland cannot get a dot yet, and in the EU only Business and Enterprise workspaces can so far.
The cloud half and the laptop half behave differently. The cloud computer stays available when the laptop is off, but anything on your machine, such as local Codex tasks or the Obsidian vault, needs that machine online with the ChatGPT app open. The cloud browser keeps its own sessions and does not inherit your logins. Some websites block cloud browsers or ask for extra verification.
Mistakes are real. OpenAI says dots can make mistakes and asks you to review important results and their sources. The follow-up-after-the-fact problem from the invoice example comes from the dot's fundamental design: it checks things on its own schedule. Usage also needs watching, because Work and Codex tasks started by a dot count toward those products' limits, and the extended limits only cover the first month after launch.
Finally, you get one dot for now. At launch, OpenAI previewed specialist dots for organizations, each with its own identity, credentials, and system access, starting as focused enterprise pilots. If more dots reach personal plans, the obvious move is one dot per role: inbox, finance, content. That mirrors the bot teams people already run on Grok Bot. Until then, one dot has to cover everything.
Giving your dot an always-on notes folder with Pinggy
The Obsidian vault in our example has teh same weakness as any local task: the dot can only write the newsletter outline while the laptop is online and ChatGPT is open. If you keep a synced copy of the vault on a machine that never sleeps, such as a mini PC, a NAS, or a Raspberry Pi, you can give the dot its own route to that folder as a custom MCP plugin. A Pinggy tunnel supplies the public HTTPS URL that ChatGPT needs to reach a box behind a home router.
Authentication shapes the entire setup. ChatGPT's custom MCP dialog offers OAuth, No authentication, or OAuth or no authentication. OpenAI's auth docs say ChatGPT cannot present custom API keys. If your gateway demands a bearer key, it will lock ChatGPT out along with everyone else. Short of running an OAuth 2.1 server, the practical setup is No authentication with two limits: the server only sees one folder of the vault, and it answers on a long random path instead of /mcp.
On that box, sync the vault to /srv/vault. Syncthing works well for this. Keep the notes you want the dot to work on, like the newsletter outline, in a Dot folder inside it. Then serve the official filesystem MCP server over Streamable HTTP with supergateway, which wraps a stdio server in an HTTP endpoint:
MCP_PATH="/mcp-$(openssl rand -hex 16)"
echo "$MCP_PATH"
npx -y supergateway --stdio "npx -y @modelcontextprotocol/server-filesystem /srv/vault/Dot" --outputTransport streamableHttp --port 8787 --streamableHttpPath "$MCP_PATH"
That serves the server-filesystem package's 14 tools, including read_text_file, write_file, edit_file, search_files, and the rest, on port 8787 at that random path, and nothing outside /srv/vault/Dot. We ran this on October 29 with supergateway 4.2.1 and server-filesystem 2.1.0. A tools/list request on the random path returned all 14 tools, a request to plain /mcp got a 404, and reading a file elsewhere in the vault returned 'Access denied - path outside allowed directories'.
Then open the tunnel from the same box:
ssh -p 443 -o ServerAliveInterval=60 -R0:localhost:8787 <token>@pro.pinggy.io
Use a Pro token from the Pinggy dashboard, with a persistent subdomain assigned to it. A free tunnel lasts 60 minutes and comes back with a new URL, which breaks the plugin URL you saved in ChatGPT. Free URLs also show a warning page to browser-like clients.
In ChatGPT on the web, turn on Developer mode if it is not already on. Open Plugins, select the plus button, then Add custom MCP server. Give it a name. Enter https://.a.pinggy.link followed by your random path as the Server URL. Pick No authentication, read the risk warning, select 'I understand and want to continue', choose Create as a plugin, then install it. OpenAI's custom MCP server guide lists the same steps, and Pinggy's guide to building a ChatGPT plugin with MCP shows where the Developer mode switch lives.
Three caveats apply. First, the random path is a secret inside a URL, not real authentication. Anyone with the full URL can read and write that one folder, so keep sensitive notes out of it and put an OAuth 2.1 layer in front of the gateway before trusting it with more. Second, OpenAI also has a private MCP tunnel option that keeps the server off the public internet entirely, but it requires an OpenAI Platform organization with Tunnels permissions and its tunnel-client running beside the server. Third, OpenAI's dots docs say a dot can use supported plugins installed and enabled for your account. One vendor reports its custom MCP connector working from the dot's first message, but this exact setup has not been tested with a dot by the original guide authors. Add a custom rule for edits to the folder either way.
The mini PC opens the tunnel outward, so no port is opened on the router and the laptop can stay closed.
Security and troubleshooting
When you start using a dot, a few questions tend to come up immediately.
Why does my dot not appear? The rollout is gradual. Even on an eligible plan, the dot entry point may not show up for a few days. Check that your ChatGPT app is updated and that you are on a supported platform. Mobile web is not supported, so use the mobile app, desktop app, or desktop browser.
Why did the dot ignore my local files? The connected computer must be online and open in the ChatGPT app. If the laptop is off, anything that depends on local files will fail. Cloud Codex tasks can continue without a local machine, but local paths cannot.
Can the dot send messages without asking? Only if your custom rules allow it. The default position is to check before actions that affect other people or external accounts. You can set 'Take action without asking' for notes and Codex tasks, but you should keep 'Ask before taking action' for sending messages to third parties.
How much does this cost in practice? The dot conversation itself does not count toward ChatGPT limits. Work and Codex tasks it starts count toward those product limits. The deeper work allowance has extended limits for the first month, but the numbers are not public. Watch your usage after that.
What if the dot keeps repeating notifications from my phone? That is the most common complaint. The fix is one clear rule: message me only if a deadline is at risk or you need a decision. Then review the dot's messages after a week and update the rule.
Can I use this with an open source alternative? Yes, the MCP pattern is vendor neutral. The same supergateway setup can expose any filesystem, and tools like Syncthing make the sync layer portable. The always-on agent itself is tied to ChatGPT for now, but the notes folder architecture is not.
What to do next
Start with work you regularly need to check or update, not a one-off request. That is OpenAI's own advice, and it matches how a dot is built. 'Keep the newsletter on schedule' or 'watch the sponsor inbox and tell me what needs a reply' gives the dot something to wake up for. Describe the responsibility, share the sources it needs, and say which decisions need you.
Then review the dot's work, tell it what needs to change, and only widen the scope once the first job runs well. Give it a week and look at what it actually caught. If most of its messages repeat notifications your phone already sends, tell it so and judge it on follow-ups instead: the invoice it double-checked, the Codex thread it reopened, the outline that was waiting in the vault on Monday morning. That is the job a chief of staff does, and it is the one thing a single chat thread never did.
Conclusion
A dot works best one layer above the tools you already use. It looks through Gmail, Google Calendar, and Slack with read-only research tools, hands research to ChatGPT Work and code to OpenAI Codex, and keeps following each job until it is done or it needs you. The order of the setup matters more than any individual setting: connect plugins and your computer, write custom rules before it goes near your inbox, give every task a finish line, and tell it in one plain sentence when to stay quiet.
Whether that is worth $100 per month depends on how much of your week goes into follow-up. If you mostly want errands run and you are in the US, Meta's Muse free tier is the cheaper bet. If you juggle Codex threads, a newsletter, and an inbox that never empties, a dot takes over the tracking you would otherwise keep in your head. Plan around two gaps while you decide: you get one dot per account for now, and anything that runs on your laptop needs the laptop online with ChatGPT open.
Top comments (0)