OpenAI Dots is a test of whether AI can carry a goal, not just complete a task

The most interesting question about OpenAI Dots is not whether it can do more than ChatGPT. It is whether, after we hand it a goal, we can stop carrying that goal ourselves.

That is a different standard. We already know modern AI can research, write, code, browse, call tools, operate software and move through multi-step tasks. The harder problem is what happens after the first instruction: whether the system can preserve enough context to keep the work coherent, notice relevant change without creating noise, act within the right boundaries, recover when the environment shifts, and return only the decisions that genuinely need a person.

Dots is interesting because OpenAI is trying to turn that harder problem into a product.

The next useful unit of AI may not be the prompt or even the task. It may be the delegated goal.

OpenAI describes Dots as an always-on assistant that can continue working across applications instead of waiting for the next prompt. Independent reporting says it runs on GPT-6 Astra, works through a cloud computer, can interact through surfaces including ChatGPT, Slack and Microsoft Teams, reaches thousands of connected apps, and is launching with one Dot per user while OpenAI explores multiple and more specialized Dots later. ChatGPT Space is designed to let people and Dots share a collaborative environment. OpenAI has also added action rules, permission controls and automated review mechanisms around that autonomy. Those facts matter, but they are not the thesis of the product. They are the machinery required for a more consequential promise: persistent delegation.

Dots is a new contract with the user

Most AI products still behave like very capable instruments. We initiate the interaction, restore the context, choose the tool, review what happened and decide when the next unit of work should begin. Even agentic products often preserve this rhythm. The system may take more steps once activated, but the user remains the person who keeps the larger objective alive.

Dots tries to change that relationship. The user is no longer only asking for an output; they are delegating continuity. In practical terms, that means the system has to remember what it is trying to achieve, understand which new events are relevant, decide which actions fit the goal, distinguish routine work from consequential decisions and maintain a usable record of what happened while the user was elsewhere.

This is why I do not think the most important comparison is Dots versus another chatbot. The more useful comparison is between AI as a tool we operate and AI as a layer that carries part of the operating burden for us.

That distinction also explains why many of the primitives behind Dots already feel familiar. ChatGPT Work can perform long, multi-step work across files and applications. Connected apps expose external information and actions. Scheduled work can continue without a new chat. Computer use gives an agent an execution surface when cleaner integrations are unavailable. Codex has already made long-running agentic work feel normal in software development. Dots does not need to invent those ingredients to matter. Its strategic move is to package continuity across them as a relationship the user can delegate to.

The real value is not more automation. It is less coordination in your head.

Knowledge work contains a large amount of coordination that rarely appears in a task inventory. A document changes after a meeting. A Slack message changes an assumption in a proposal. Research invalidates an earlier recommendation. A stakeholder asks for a different version. A deadline moves. A customer response means the next step is no longer the one originally planned. AI can already help with each event individually; the human cost is keeping all of them connected to the same objective.

That is where persistent agents could create a different kind of leverage. If a Dot can preserve the relationship between the goal, the work already done and the systems where relevant changes appear, it may remove some of the mental overhead of keeping the project alive. The productivity gain would not simply be faster execution. It would be attention recovery.

That also changes what we should measure.

An agent can be extremely busy and still create very little leverage. If it performs fifty actions but asks the user to inspect forty-five of them, the coordination burden has not disappeared; it has changed shape. A quieter system that correctly handles routine work, returns compact decisions when judgment is needed, and refuses the cases it should not touch may be far more valuable.

I have argued before that the hidden metric in AI automation is supervision. Dots makes that argument more concrete. The useful outcome is not that the agent does more while I am away. It is that more responsibility can safely leave my active attention without returning as review, correction, explanation or recovery.

Persistence is the strength, and the liability

A persistent agent becomes valuable by accumulating context. It needs some durable understanding of what you are trying to accomplish, what has already happened, what changed, what you rejected, which constraints matter and how the next decision relates to the previous ones. Without that continuity, an always-on assistant is mostly a scheduler wrapped around repeated rediscovery.

The same mechanism also changes how mistakes propagate. A normal chat can misunderstand a request and produce a bad answer that largely dies with the session. A persistent agent can carry a wrong assumption into tomorrow's research, the next document, another application and a later action. An inferred preference can slowly become a false rule. An obsolete fact can survive long enough to influence several downstream choices before anyone notices.

I think this creates a form of context debt. The better an agent becomes at remembering, the more important it becomes to know what it currently believes, where that belief came from, whether it is observation or inference, how long it should remain valid and how easily the user can correct it. Persistent AI moves consequential state into places that are much less legible than a traditional database field: conversation histories, summaries, memory, retrieval results, tool outputs and generated interpretations.

This is one of the places where Dots could become genuinely better than today's AI, or simply more exhausting. If the user has to periodically audit the agent's internal picture of the world, clean up stale context and correct invisible interpretations, then persistence has not removed management. It has created a new kind of maintenance.

Delegation turns permissions into product design

The next problem is authority. A system that only recommends can be useful with fairly broad access because the user still decides whether anything consequential happens. A persistent system becomes valuable precisely when it can act without stopping for approval every few minutes. That means the product must decide, somehow, which actions can disappear into the background and which must return to a person.

OpenAI's reported use of configurable action rules, permissions and automated review around Dots is therefore not a secondary safety feature. It is central to the product proposition. If every action requires synchronous confirmation, persistent delegation collapses back into supervised task execution. But removing approval prompts does not remove the decision. It moves the decision into policy, permissions, risk thresholds, reviewer models and environment boundaries.

This is where one distinction matters more than almost anything else: capability is not authority. A Dot may be able to read a calendar, move a meeting, draft an email, send it, edit a customer proposal, place an order or update a system of record. Those actions should not inherit the same authority simply because the agent can technically perform them. Delegation needs gradients.

For an ordinary user, the challenge is to make those gradients understandable without requiring them to become a security architect. For an enterprise, the problem is larger because authority already exists in roles, approvals, separation of duties, policies, data entitlements and informal exceptions. An agent does not remove that structure. It forces the structure to become executable.

The hidden strategic move is ownership of continuity

There is also a platform question underneath the product. If Dots works as intended, OpenAI is no longer only providing the model that answers a request or the application where the conversation happens. It becomes the layer that knows the user's goals, remembers the work, connects the applications, carries operating history and decides when the next action should happen. That is a strategically powerful position because continuity is harder to move than a single prompt.

This is an inference, not a claim about OpenAI's stated strategy. But the product logic is difficult to ignore. The more useful a persistent agent becomes, the more context, rules, permissions, relationships and workflow history accumulate around it. Switching assistants then stops being equivalent to choosing a different model. The user may be moving an operating layer.

That creates upside for users because a coherent layer can reduce fragmentation across today's collection of chats, projects, tools, automations and agents. It also creates a new dependency. The more work a Dot coordinates, the more important portability, inspectability and control over accumulated context become. A persistent agent should ideally make it easier to move work through the organization without making the organization increasingly dependent on one invisible state machine.

The cloud computer removes one constraint and exposes another

Dots also pushes the execution environment away from the user's device. A cloud computer means work can continue when the laptop closes and gives the agent a durable place to use connected services and interfaces. For long-running work, that is an obvious advantage.

It also exposes the difference between applications that are genuinely agent-ready and applications that are merely operable through a human interface. Computer use can let an agent click through software designed for people, but the fact that something can be automated visually does not mean its semantics are clear enough for safe delegation. Human interfaces contain conventions, implied consequences, stale labels and organizational context that people resolve almost without noticing.

In The next AI interface may never be seen, I argued that agent-ready systems increasingly need machine-callable capabilities rather than only human-readable screens. Dots can widen the range of software an agent can operate. The more important long-term opportunity is to redesign software so the underlying capabilities, permissions and consequences are legible to machines by construction.

That would make persistent agents more reliable not because the model became smarter, but because the environment became less ambiguous.

Dots may expose the organization before it improves it

This matters even more in companies. A persistent agent connected to many applications can look like an automation engine, but it is also an unusually effective test of how coherent the operating environment actually is.

Many organizations run on contradictions that humans quietly repair. Two systems disagree. A policy is technically current but operationally ignored. A process contains an approval step whose original reason disappeared years ago. A customer exception lives in the memory of one experienced employee. A broad permission exists because changing it would break three legacy workflows. People navigate these conditions socially, using context that is rarely documented as executable logic.

A Dot cannot make that ambiguity disappear. If anything, it can make it operational. That is the less flattering side of the automation opportunity: a powerful agent can automate organizational confusion faster. But it is also an opportunity. The places where the agent repeatedly needs escalation, encounters conflicting sources, requests unnecessary access or cannot determine who owns a decision are signals about the operating model around it.

The companies that learn most from persistent agents may therefore not be the ones that connect the greatest number of applications first. They may be the ones that treat agent failure as organizational evidence.

Reliability has to include recovery, not just completion

The technical glitches reported during the DevDay demonstration are not especially interesting as launch drama. Live demos fail. What matters is the standard a product like Dots eventually has to meet.

A chatbot can remain useful despite occasional mistakes because many interactions are cheap to retry. Persistent delegation is different. The system may fail after the user has stopped watching, after several earlier actions have succeeded and after the surrounding environment has changed. It has to survive expired authentication, unavailable tools, contradictory information, partial completion, changing permissions and stale assumptions. It also needs to know whether to retry, recover, ask, escalate or stop.

That is why I think the benchmark needs a runtime address. Once behavior depends on the configured system rather than a model label alone, the evidence has to include the actual route, tools, permissions, policies and operating conditions under which the agent acted.

For persistent agents, I would add another requirement: recovery needs to be measured as part of capability. A system that completes impressive work when everything is available but turns every exception into detective work for the user has not removed coordination. It has deferred it until the most expensive moment.

The real test is whether we can stop managing the AI

This is why Dots interests me even if many of its individual capabilities already exist elsewhere. It turns a collection of technical primitives into a sharper product question: can an AI system carry a goal without forcing the user to carry the coordination of that goal in parallel?

If the answer becomes yes, the change is significant. We will not simply use AI for more tasks. We will begin to hand over parts of the continuity that currently lives in our heads: remembering what matters, noticing what changed, keeping work connected across applications and deciding which routine actions no longer deserve active attention.

If the answer is no, the failure may have little to do with model intelligence. Persistent agents can become another layer to configure, monitor, correct and periodically clean up. Context can accumulate faster than trust. Permissions can become harder to reason about. Review can return as notification overload. Recovery can turn invisible autonomy into visible management work.

Dots therefore has a higher bar than being impressive. The successful version is not the busiest agent, the agent with the most integrations or even the agent that can operate for the longest time without interruption. It is the one we can safely stop managing.

That is the real promise of delegation, and the real risk if the product cannot reach it.

Sources