OpenAI Dots: Always-On AI Agents Explained

OpenAI's Dots, announced at DevDay 2025, gives ChatGPT users always-on AI agents that operate with their own dedicated cloud compute. Rather than waiting for a user to type a prompt, a Dots agent accepts a goal and carries it forward independently — checking in only when a decision genuinely requires human input.

That is a meaningful shift in architecture, not just a feature update. The model moves from reactive (answer when asked) to persistent (work continuously until the task is done). For businesses already thinking about autonomous agents, it raises questions worth addressing carefully.

How Do Always-On AI Agents Actually Work?

Traditional chat AI operates in a request-response loop. A user sends a message; the model returns a reply; the session ends or pauses. Dots breaks that loop by giving each agent its own execution environment in the cloud — persistent compute that stays alive between interactions.

This means an agent can monitor an inbox, track a data source, or manage a multi-step workflow without a human re-initiating each step. The agent holds state across time, which is what makes it genuinely autonomous rather than merely automated.

Three capabilities underpin this design:

• Persistent memory: The agent retains context between sessions rather than starting fresh each time.
• Dedicated cloud compute: Each agent runs in its own environment, isolated from other sessions.
• Goal-driven execution: The agent works toward an objective, deciding which steps to take rather than following a fixed script.

Persistent compute changes the governance question. An agent that runs continuously is one that can act — and err — without a human in the loop.

What Should a Business Consider Before Deploying This Kind of Agent?

The capability is genuinely useful. But persistent, goal-driven agents introduce governance considerations that episodic chat tools do not. When an agent acts continuously, the organisation needs to know: what is it authorised to do, how are those actions logged, and what triggers a human review?

Those questions apply whether the agent is built on Dots, a custom stack, or any other persistent architecture. The underlying principle is the same — autonomy without accountability boundaries is a liability, not a feature.

Before deploying always-on agents, a business should work through at least four governance checkpoints:

1. Scope definition: What actions is the agent permitted to take, and what requires human approval?
2. Audit logging: Is every action recorded in a way that can be reviewed after the fact?
3. Escalation triggers: Under what conditions does the agent pause and route to a human?
4. Data handling: What information does the agent retain, and for how long?

These are not hypothetical concerns. As explored in earlier analysis on how agentic systems can erode audit trails, the gap between what an agent does and what a business can prove it did is a real operational risk.

Where Does This Architecture Fit in Practice?

Always-on agents are well-suited to tasks where the work is continuous but low-stakes enough to proceed without constant oversight — monitoring, triage, scheduling follow-ups, or managing intake queues across time zones. They are less suited, without careful guardrails, to tasks involving financial commitments, sensitive data decisions, or irreversible actions.

The Dots launch signals that persistent agent infrastructure is moving into mainstream consumer and developer tooling. That matters because it normalises the architecture — businesses will increasingly encounter vendors offering always-on agents, regardless of whether the underlying governance is mature.

The right response is not to avoid the architecture. It is to adopt it with clear scope, logged actions, and human escalation paths built in from the start. Provable control — the ability to demonstrate what an agent did and why — is what separates a well-deployed autonomous agent from an operational liability.

Plus Bytes designs always-on agent deployments with governance structure built into the architecture, not added as an afterthought. If your business is evaluating persistent AI agents, the governance design is where the conversation should start.

Further Reading: siliconangle.com