The most familiar way to use ChatGPT looks like this:

You ask a question
  ↓
The AI answers
  ↓
The conversation ends

But Dots, which OpenAI unveiled on September 29, 2026, starts from a different place.

You give a Dot an ongoing responsibility rather than a one-off question:

"Keep tracking this project."
"Check my calendar every day and tell me what to prepare."
"Keep researching this topic and bring me important changes."

And a Dot does not stop everything just because the conversation ended.

OpenAI calls this an always-on agent.

How is it different from regular ChatGPT?

Drawn as simply as possible, it looks like this:

Regular ChatGPT

Message
  ↓
Reasoning
  ↓
Answer


Dot

Long-term goal
      ↓
Context + Memory
      ↓
Connected apps
      ↓
Cloud computer
      ↓
Scheduled / proactive work
      ↓
Summarized result
      ↓
Asks you a question when needed
      ↺

A Dot runs on GPT-6 Astra and can have its own cloud computer.

It reads information from the apps you connect, remembers long-term context, and keeps carrying on scheduled tasks and ongoing work.

The point is that it is closer to an AI that holds a responsibility than an AI that answers questions.

Memory alone is not what matters most in a persistent agent

"Remembering things over time" can sound like an ordinary memory feature.

But a real persistent agent needs four axes:

1. Goal
   What must be achieved on an ongoing basis?

2. State
   How far along is the work right now?

3. Tools
   What can it read, and what can it run?

4. Permission
   How far may it go on its own?

Dots is an attempt to bundle these four at product level.

For a calendar-management Dot, for example, you could split the roles like this:

Goal
"Never miss an important event"

State
"A presentation is tomorrow and the slides are unfinished"

Tools
Calendar / files / connected apps

Permission
Reading: automatic
Changing events: approval required
Sending external messages: approval required

Proactive research is not "acting on its own"

One reason Dots is interesting is that it can find information before you ask, without waiting for a question.

OpenAI calls this proactive research.

But at launch, there is an important limitation here too.

The proactive research tool cannot directly:

  • send messages to other people,
  • change content through plugins, or
  • control the browser or computer.

So conceptually it is closer to this:

Background research
──────────────
Read + summarize + private notes
         ↓
Spot a change worth reporting
         ↓
Bring it to you
         ↓
Actions need separate permission / approval

"Always on" and "always acting on its own" are two completely different stories.

Why approvals become a core feature of persistent agents

When a short chat goes wrong, usually one answer is wrong.

When a persistent agent goes wrong, real state can change:

The wrong email sent
The wrong calendar change
The wrong file edit
The wrong purchase

So the more capable an agent becomes, the more its permission design matters.

In Dots, Custom Rules roughly divide supported actions like this:

Allow
Runs on its own

Ask
Needs your approval before running

Block
Never runs

But Custom Rules cannot switch off every safety guard.

OpenAI explains that core safety requirements, separate auto-review, and proactive research limits cannot be lifted with Custom Rules.

You can even connect your own computer

A Dot uses its own cloud computer by default.

Local computer access is separate and off by default.

If you connect your computer in the desktop app and grant access, the Dot can work with files on that machine or do tasks that need the local browser.

Split the structure and it looks like this:

                  ┌─ Cloud computer
Dot ─────────────┤
                  └─ Local computer (only if explicitly connected)

This distinction matters too.

Just creating a Dot does not automatically give it access to your entire local PC.

CodeBridge Mini Lab: draft the permission table before you build an always-on agent

You can practice the design even before building a real Dot.

Say you are building a "development project management agent."

First, list every action it could take:

Read GitHub issues
Read PR status
Read build results
Create a new issue
Close an issue
Merge a PR
Send a Slack message

Then classify each one:

Action Allow Ask Block
Read issues ✓
Check build status ✓
Create an issue ✓
Merge a PR ✓
Delete production ✓

What matters here is not how smart the agent is.

The principle is this: the costlier a mistake would be, the stronger the constraint should be.

"Proactive" needs a different kind of evaluation too

For an ordinary chatbot, checking whether the answer is right is enough.

For a persistent agent, that is not enough:

Did it find accurate information?
+
Did it notify you only when needed?
+
Are there no duplicate notifications?
+
Did it avoid actions that needed approval?
+
Does it hold the same goal days later?

In other words, evaluation widens from accuracy to reliability and policy adherence.

OpenAI's GPT-6 Astra system card also treats Dots as a separate harness and says it ran dedicated evaluations on how long-horizon proactive work affects alignment.

A persistent agent is really a small operating system

If you see a Dot as just "one more character added to ChatGPT," the structure stays invisible.

Looked at a little more technically, it is this:

Model
+
Memory
+
Apps
+
Computer
+
Scheduler
+
Rules
+
Approvals
+
Subagents
=
Persistent Agent

If any one of these wobbles, long-term stable work gets hard.

The longer the work runs, the more context management, checkpoints, permissions, and verification matter.

The bottom line: the next race after chatbots may be about who can hold responsibility longest

The biggest change Dots shows is not the UI.

AI used to be a tool you called when you needed it.

Dots points toward AI you hand a goal to, which keeps its state between conversations and keeps working.

Chatbot
"Answer this for me right now"

↓

Persistent Agent
"Keep holding this responsibility"

As this gap grows, designing long-term goals, permissions, verification, memory, and repeatable structure will likely matter more than writing one good prompt.

Further reading

References

Go deeper with a course

If you want to practice building controllable agents that keep working for a long time, a guided course on harnesses, loops, and graphs is the closest next step.