OpenAI Dots Explained: Always-On ChatGPT Agents, What They Can Do, and What They Can't

TL;DR: OpenAI Dots are persistent ChatGPT agents that OpenAI launched at DevDay on September 29, 2026. Each Dot runs on GPT-6 Astra, gets its own cloud computer and browser, connects to more than 4,000 apps through OpenAI's plugin ecosystem, and keeps working after you close the chat. You can reach it in ChatGPT, Slack, Microsoft Teams and by voice. The first Dot is included at no extra cost on Pro and Business Premium, and Enterprise, Edu and Healthcare get a beta once an admin enables it. They're useful for long-running, well-scoped work. They're risky for anything where a mistake can't be undone, because stopping a Dot doesn't reverse actions it already completed. Below: how Dots work, what they can't do yet, who should use them, and a small pattern for making long-running agents safer.

This is one of four deep dives that follow my overview, Agentic AI in October 2026: Agents Now Need Owners. The others cover Atlassian AMP, Oracle Fusion Claw and the agentic commerce trust gap.

What Are OpenAI Dots?

A Dot is a named, long-lived agent attached to your ChatGPT account. Until now, ChatGPT worked one turn at a time: you asked, it answered, and it stopped. A Dot keeps going. VentureBeat describes it as a "persistent AI agent designed to keep working after an employee closes the chat window" [1].

Each user starts with one primary Dot. You can give it a name, an avatar and a handle such as @yourname-dot [3], and it keeps context across channels, so a task you start in Slack can continue in ChatGPT [2].

Sam Altman announced it on X as a way to use AI around the clock [2]. The more accurate description is a coworker that stays logged in: it researches, drafts, analyzes data and prepares software changes, then brings results back for review.

How Dots Work

OpenAI's own example workflows include tracking customer feedback, preparing bug fixes and opening pull requests for review, and revising launch materials when a product's scope changes. Runtime Wire notes these are OpenAI's examples, not independent evidence of reliability [2].

The Controls OpenAI Built In

Most of the launch was about control rather than raw capability:

• App access: you choose which apps a Dot can use [1][2].
• Custom Rules: you can permit an action, require approval for it, or prohibit it [1]. A rule can require a draft review before a message is sent, but rules can't override OpenAI's built-in safety requirements [3].
• Automated review: an automated reviewer decides whether a consequential action proceeds, needs approval, or goes back to you [1][3].
• Activity View: shows the Dot's background work so you can step in [1].
• Sensitive actions: anything that changes an account or shares information outward needs integration permission or explicit approval [3].
• Training data: content from ChatGPT Business, Enterprise and Edu workspaces isn't used to improve models by default [4].

Pricing and Availability

Usage details that matter for budgeting:

• Conversations with a Dot don't count toward ChatGPT usage limits, but tasks it starts in Codex or ChatGPT Work use those products' quotas [2][3].
• Plans include an allowance for "deeper work," and OpenAI hasn't said how big it is [2][4].
• Pricing for additional Dots hasn't been published [1][4].
• Setup happens on desktop. Mobile apps work afterwards, and mobile web isn't supported at launch [2][3].

What Dots Can't Do Yet

These limits come from OpenAI's own materials and the launch coverage:

1. 01Stopping doesn't undo. Stopping a task doesn't reverse actions already completed, and pausing the main task doesn't cancel delegated background work or scheduled runs [3].
2. 02You can't edit its memory. You can't view, change or delete individual memories, and disconnecting a plugin doesn't erase context the Dot already kept [4].
3. 03No email address or outbound calls. At launch a Dot can't place calls or have its own email address, and texting is "coming soon" [4].
4. 04"Always on" isn't an uptime promise. No uptime SLA, reliability metrics or Dots-specific compliance attestation was published [4].
5. 05One Dot to start. Teams of Dots are planned for later. Enterprise "specialist" Dots with their own identities and access to company systems are still in pilot [2][4].
6. 06It makes mistakes. OpenAI says so directly and advises reviewing consequential work [2].

There were also signs the launch was rushed. Axios reported lag when an OpenAI employee tried to talk to her Dot during a DevDay demo [2]. AlphaSignal reported that OpenAI dropped plans to launch Dots on GPT-6.1 Astra over safety concerns and shipped on GPT-6 Astra instead [3].

Do You Need a Dot?

Forbes' Ron Schmelzer asked this directly [5]. My answer depends on the work:

The rule I use: give a Dot a narrow job with a clear output and no irreversible actions. Read-only research and draft-for-review work is where it saves time without adding risk.

Build It: An Undo Ledger for Long-Running Agents

The most important limitation for builders is the first one: stopping doesn't undo. That's true of nearly every agent framework, not just Dots. If you build your own long-running agents, record every side effect together with a way to reverse it, so that "stop" can also roll back.

This runs on Node 22+ with npx tsx dots-ledger.ts and needs no dependencies:

// dots-ledger.ts: run with `npx tsx dots-ledger.ts` (Node 22+)
// A long-running agent records every side effect with a way to reverse it,
// so "stop" can also mean "roll back what you already did".

type Step = {
  id: string;
  description: string;
  undo?: () => Promise<void>; // omit when the action cannot be reversed
};

class ActionLedger {
  private done: Step[] = [];
  private stopped = false;

  async run(step: Step, action: () => Promise<void>) {
    if (this.stopped) throw new Error(`stopped before "${step.description}"`);
    await action();
    this.done.push(step);
    console.log(`done:   ${step.description}`);
  }

  // Stop the agent and undo completed steps, newest first.
  async stopAndRollBack() {
    this.stopped = true;
    for (const step of [...this.done].reverse()) {
      if (step.undo) {
        await step.undo();
        console.log(`undone: ${step.description}`);
      } else {
        console.log(`MANUAL: "${step.description}" cannot be undone, tell the owner`);
      }
    }
    this.done = [];
  }
}

async function main() {
  const ledger = new ActionLedger();
  const noop = async () => {};

  await ledger.run(
    { id: "1", description: "create draft doc 'Q4 launch plan'", undo: async () => {} },
    noop,
  );
  await ledger.run(
    { id: "2", description: "add label 'launch' to 12 Jira issues", undo: async () => {} },
    noop,
  );
  await ledger.run(
    { id: "3", description: "post update in #launch Slack channel" }, // no undo: people saw it
    noop,
  );

  // The owner notices the agent misread the scope and hits stop.
  await ledger.stopAndRollBack();

  await ledger
    .run({ id: "4", description: "email 40 customers" }, noop)
    .catch((e) => console.log(`blocked: ${e.message}`));
}

main();

Output:

done:   create draft doc 'Q4 launch plan'
done:   add label 'launch' to 12 Jira issues
done:   post update in #launch Slack channel
MANUAL: "post update in #launch Slack channel" cannot be undone, tell the owner
undone: add label 'launch' to 12 Jira issues
undone: create draft doc 'Q4 launch plan'
blocked: stopped before "email 40 customers"

What this pattern gives you:

• Every step is reversible or explicitly marked as not. Steps without an undo are flagged for a person, so the owner knows exactly what needs a manual fix (here, the Slack post people already saw).
• Rollback runs newest first, the same order a database transaction unwinds.
• Stop blocks new work, so the agent can't start emailing customers after you've told it to halt.

In production, store the ledger durably (a table keyed by run ID) and make each undo idempotent. For more patterns like this, see my guide to agentic AI error recovery and observability and the agentic error recovery skill.

My Take

Dots are the clearest sign yet that the chat window is no longer the main way people use AI. An agent that keeps working while you're away is a different product from one that answers questions, and it needs a different level of trust.

OpenAI built a reasonable set of controls: Custom Rules, auto-review, Activity View and read-only idle research. The gaps are the parts that matter for real work: memory you can't audit, no undo, and no published reliability data. Use Dots for research and drafts now, and wait for those gaps to close before giving one write access to anything important.

For how Dots compare with what Atlassian, Oracle and SAP shipped the same fortnight, read the agentic AI October 2026 overview.

References

1. 01VentureBeat, "OpenAI launches Dots, always-on AI agent coworkers, and ChatGPT Space where they can collaborate with human teams," September 29, 2026. venturebeat.com
2. 02Runtime Wire, "OpenAI launches Dots, always-on agents that work across connected apps." runtimewire.com
3. 03AlphaSignal, "OpenAI's Dots Turns ChatGPT Into a Persistent Agent That Works While You Sleep." alphasignal.ai
4. 04Spinnable, "What Is OpenAI dots? Always-On Agents Explained (2026)." Note: Spinnable sells a competing product. spinnable.ai
5. 05Ron Schmelzer, "What Are OpenAI Dots And Do You Need Them?", Forbes, October 5, 2026. forbes.com
6. 06Forbes, Agentic AI topic page. forbes.com/topics/agentic-ai

Harsh Rastogi is an AI Product Engineer at Modelia, building production generative-AI systems for fashion commerce, and the creator of carcode. He writes about AI systems, developer tooling and production engineering at harshrastogi.tech.