OpenAI Dots: What Always-On AI Agents Mean for Skills, Plugins, and Agent Workflows

OpenAI's new Dots are a useful signal of where AI agents are heading next.

Announced on September 29, 2026, Dots are always-on agents inside the ChatGPT ecosystem. They are powered by GPT-6 Astra, run on their own cloud computer, can keep making progress between conversations, and can work across the apps a user chooses to connect.

That makes Dots different from the familiar pattern of opening a chatbot, sending a prompt, receiving an answer, and starting again later.

A Dot can be given an ongoing responsibility. It can maintain context, work in the background, use connected tools, ask for approval when needed, and return with progress or completed work.

For developers following the rise of AI agents, MCP servers, reusable skills, and plugin-based workflows, the important part is not simply that OpenAI has launched another agent product.

The larger shift is toward persistent AI systems that combine model intelligence, reusable instructions, tools, connected apps, memory, and long-running execution.

OpenAI Dots at a glance

OpenAI describes Dots as always-on agents designed to take on ongoing work.

At launch, a Dot can:

run on its own cloud computer;
keep working between conversations;
use a browser and connected apps;
remember context for ongoing work;
learn from feedback over time;
handle scheduled and recurring tasks;
communicate through ChatGPT and supported messaging channels;
ask for approval before actions that require user judgment;
continue making progress without needing every step explicitly directed.

OpenAI also says its plugin ecosystem can connect Dots to more than 4,000 apps.

That combination matters because an agent is only as useful as the context, instructions, and tools it can access.

A strong model may be able to reason about a task, but persistent real-world work usually requires more:

Model intelligence → instructions and skills → plugins and tools → connected systems → ongoing execution

Dots bring those layers together into a single long-running agent experience.

What makes a Dot different from a regular ChatGPT conversation?

A normal ChatGPT conversation is primarily request-driven.

You ask a question or give a task. ChatGPT responds. You may continue the conversation, but the interaction is still centered on individual turns.

A Dot is designed around ongoing responsibility.

OpenAI says a Dot can be given a goal, determine what needs to happen next, keep making progress between conversations, and bring results back for review.

That makes the unit of work different.

Instead of:

Prompt → response

the workflow becomes closer to:

Goal → planning → actions → monitoring → iteration → review

This may sound like a small change in interface, but it changes how developers need to think about agent systems.

The more autonomy an agent has, the more important it becomes to give it:

reliable instructions;
appropriate tools;
clear permissions;
persistent context;
checkpoints for review;
ways to verify the result.

Those are exactly the areas where skills, plugins, MCP servers, and agent tooling become increasingly important.

Why plugins matter more for always-on agents

OpenAI's current plugin model combines several different types of capability.

A plugin can include:

skills, which provide reusable instructions and workflow guidance;
connected apps, which link external accounts, data, and actions;
app templates for workspace configuration;
extensions and other workflow capabilities.

This distinction is important.

A connected app may give an agent access to data or actions.

A skill may tell the agent how to use those capabilities effectively.

An always-on agent needs both.

For example, access to a project tracker lets an agent read or update issues. But that does not automatically tell the agent how a particular engineering team triages bugs, prioritizes work, validates fixes, or prepares a release.

Those procedures can live in reusable instructions or skills.

The plugin becomes the package that can bring the knowledge and the tools together.

That is a much more powerful model than treating integrations as simple API connections.

Where AI skills fit into the Dots model

AI skills are becoming increasingly important because persistent agents need specialized operating knowledge.

A general-purpose model may understand programming, product management, support, research, or analytics. But a real workflow often depends on organization-specific or tool-specific details.

A useful skill can encode things such as:

which files or systems should be checked first;
what sequence of actions should be followed;
which tool should be used for each step;
which edge cases should trigger caution;
what validation should happen before completion;
when the agent should stop and ask for human approval.

This is similar to the pattern we discussed in our article on Unity's official AI skills for Claude Code and Codex.

The model provides general reasoning.

The skill provides specialized procedure.

The tools provide actions.

The persistent agent coordinates the work over time.

With Dots, that stack becomes especially clear because the agent is designed to keep responsibility for a goal rather than simply answer one prompt.

Dots, MCP servers, and plugins solve related but different problems

It is tempting to group every agent integration technology together, but they serve different roles.

An MCP server exposes tools, resources, or external capabilities through the Model Context Protocol.

A connected app gives ChatGPT or another OpenAI surface access to an external service.

A plugin can package skills, connected apps, and workflow capabilities together.

A Dot is the persistent agent that can coordinate work using the capabilities it has been given.

These concepts overlap, but they are not interchangeable.

OpenAI does not describe Dots as an MCP-based product. MCP servers and OpenAI plugins are separate integration approaches.

The useful comparison is architectural.

Both plugin-based systems and MCP-based systems are attempts to solve one of the central problems of agentic AI:

How does a model reliably reach the tools, data, and specialized knowledge required to complete real work?

For a deeper comparison, see Claude Code Skills vs MCP Servers.

The cloud computer changes what an agent can do

One of the most important parts of Dots is that each Dot has its own cloud computer.

That means the agent is not limited to calling a narrow set of APIs.

Depending on permissions and workspace settings, it can use a browser, interact with supported applications, work with files, and execute tasks in an environment that continues running independently from the user's local machine.

OpenAI also allows optional access to a user's local computer, but that starts turned off and must be explicitly enabled.

This separation matters for both usability and security.

A persistent agent needs somewhere to keep working.

Giving it an isolated cloud environment creates a place where it can:

maintain intermediate work;
use a browser;
run commands;
interact with cloud applications;
continue tasks while the user is away;
expose its progress for inspection.

This is closely related to the broader trend toward long-running cloud agents described in OpenAI's Agents API.

The agent is no longer simply a model endpoint.

It becomes a software process with memory, tools, state, permissions, and an execution environment.

Persistent agents make permission design more important

More autonomy also means more responsibility.

OpenAI emphasizes that Dots operate within permission and approval controls.

Users choose which apps a Dot can access. Dots have built-in rules for deciding when they can act independently and when they need approval. OpenAI also provides custom rules that can allow, require approval for, or block specific types of actions.

This is not a secondary feature.

It is fundamental to persistent agents.

A chatbot that only generates text has a limited action surface.

An always-on agent with access to email, files, browsers, project systems, cloud services, and business applications can have a much larger impact.

That makes agent design increasingly about more than intelligence.

It is also about:

least-privilege access;
approval boundaries;
action logging;
task visibility;
safe defaults;
reliable verification.

As agents become more capable, these control layers may matter as much as raw model performance.

From individual assistants to teams of agents

At launch, OpenAI is starting with a primary Dot for each user.

But the company has already said it envisions teams of Dots working together over time.

It is also previewing specialist Dots for organizations: agents with dedicated identities, credentials, systems access, and clearly defined responsibilities.

That points toward a future where organizations may not have one general-purpose agent.

They may have several specialized agents.

For example:

an engineering Dot that monitors issues and prepares fixes;
a support Dot that investigates recurring customer problems;
a research Dot that tracks new evidence and updates analyses;
a finance Dot that prepares routine operational work;
a marketing Dot that maintains campaign assets and reporting.

The coordination problem then becomes increasingly important.

Specialized agents will need shared standards for:

skills;
tools;
permissions;
memory;
task handoffs;
identity;
evaluation;
auditability.

This is one reason the wider ecosystem of AI skills and agent tooling matters.

What Dots mean for developers

For developers, Dots reinforce several trends that were already visible across modern agent platforms.

1. The prompt is becoming less central

Prompts still matter, but long-running systems need reusable operating knowledge.

A persistent agent should not require the user to restate the same procedures every time.

Skills and structured instructions make behavior easier to reuse, review, and maintain.

2. Tools need context

Giving an agent an API or browser is not enough.

The agent also needs to know when and how to use that capability.

That makes the relationship between skills and tools increasingly important.

3. State becomes a first-class part of the system

When an agent works across hours, days, or recurring tasks, developers need to think about what it remembers, what it stores, and how it resumes work.

4. Verification becomes part of the workflow

The longer an autonomous workflow runs, the more opportunities there are for an early mistake to affect later actions.

Good agent systems need checkpoints, validation, and review.

5. Agent infrastructure becomes its own software layer

Cloud execution, scheduling, permissions, memory, connected apps, plugins, and tool access are becoming infrastructure around the model.

The model remains important, but it is only one part of the complete system.

Are Dots the next step after AI copilots?

The term "copilot" usually describes software that assists while a user is actively working.

Dots point toward something different.

The agent can keep responsibility for a goal even when the user is not continuously interacting with it.

That is closer to delegation than assistance.

The difference is important:

Copilot: "Help me do this."

Persistent agent: "Take responsibility for this and bring me in when needed."

In practice, the boundary will remain blurry. Users will sometimes work interactively with a Dot and sometimes delegate ongoing work.

But the direction is clear.

The industry is moving from AI that responds to AI that can maintain context, use tools, execute tasks, and continue working toward an objective.

What to watch next

Dots are still early, and several developments will be worth watching.

The most important include:

multiple Dots working together;
specialist agents with dedicated organizational roles;
richer plugin ecosystems;
more reusable skills packaged with tools;
stronger permission and approval models;
better observability for long-running agent work;
interoperability between agent platforms and external tool standards;
new ways to evaluate whether persistent agents are actually completing work correctly.

Another important question is whether developers begin publishing more agent-ready knowledge.

If software vendors package not only APIs but also reusable instructions, skills, workflows, and validation rules, agents will have a much better chance of operating those systems reliably.

The bigger takeaway

OpenAI Dots are interesting because they make persistent agency a mainstream product concept.

The important shift is not simply that an AI agent can run in the background.

It is that the agent combines:

a frontier model + persistent context + cloud execution + skills + plugins + connected apps + permissions

That stack is much closer to a long-running software worker than a traditional chatbot.

For the AI skills ecosystem, this strengthens the case for reusable, maintained knowledge.

As agents take on longer and more complex responsibilities, they will need more than intelligence.

They will need the right expertise, the right tools, and clear rules for using both.

Browse AI agent skills, explore MCP servers, or read Claude Code Skills vs MCP Servers to explore the building blocks behind modern agent workflows.

Sources