Just a few years ago, interacting with artificial intelligence was as simple as it gets: a person would open a chat, type a question, and wait for a response. ChatGPT could explain a complex topic, write a letter, summarize a text, or help with code, but virtually every new action was initiated by a person. AI remained a very powerful tool, but still one that needed constant guidance.

Following OpenAI DevDay 2026, this model seems increasingly outdated. At the conference on September 29 in San Francisco, the company made over 20 major announcements—ranging from new models and Codex capabilities to the Agents API and the always-on Dots agents. However, what’s far more interesting isn’t the number of new products OpenAI unveiled, but how they fit together into a single system. In this system, humans are increasingly less likely to explain every next step to the AI; instead, they formulate a goal, grant access to the necessary tools, and monitor the outcome.

UA.News explains why DevDay 2026 can be seen as another major step for OpenAI—moving beyond a standard chatbotbot to an AI system capable of independently working with applications, files, code, and enterprise services, performing long-running tasks in the cloud, and turning to a human only when a decision or authorization is needed.

OpenAI DevDay revealed the main direction of ChatGPT’s development 

At the very beginning of ChatGPT’s history, the primary value was the response. A person would ask a question—the model would generate text. Later, file analysis, information search, image generation, code handling, voice capabilities, and integration with external services were added.

But the logic remained roughly the same: the user would approach the AI and ask it to do something. Now OpenAI is trying to turn this model on its head.

As a result of DevDay 2026, the company is explicitly talking about agents capable of taking on “ongoing responsibilities”—that is, not isolated, one-time requests, but continuous tasks. This is an important distinction. It’s no longer just about asking ChatGPT to prepare a document, but about a system that can monitor a specific process, respond to changes, and take the next steps without requiring a new prompt at every stage.

That is precisely why the individual DevDay announcements should be considered together. Dots enable AI to operate continuously. The Agents API allows developers to embed such agents into their own products. Computer Use enables them to interact with applications through an interface. Codex demonstrates how this approach already works in programming: an agent receives a task, works with files and code on its own, runs checks, and delivers the final result.

Whereas the typical scenario used to be “ask—get an answer,” the new model increasingly resembles “set a goal—grant access—verify the result.” In the long run, this very difference may prove to be far more important than yet another increase in the number of parameters or model results in benchmarks.

Dots — an OpenAI agent that doesn’t wait for a new message from the user

The most striking example of this new approach is OpenAI’s Dots agents. The company describes them as “always-on agents”—agents that can remain active at all times. Each Dot runs on GPT-6 Astra, has its own cloud computer, and can perform tasks around the clock. Through a plugin ecosystem, the agents can connect to over 4,000 applications, according to OpenAI.

In its presentation on Dots, OpenAI provides several scenarios that clearly illustrate the difference between such an agent and a standard chatbot. For example, for a developer, a Dot can monitor user feedback, identify recurring issues, independently determine minor fixes, write code, test it, and prepare a pull request. All the developer has to do is review the result.

For a content creator, the agent can generate a new transcript of an interview, select clips for short videos, prepare descriptions and social media posts, and incorporate the author’s previous edits.

For a researcher, this means monitoring the arrival of new data, rerunning analyses, updating graphs, and notifying the researcher if the results have changed enough to require human intervention.

OpenAI even cites an example from early testing where Dot noticed that a user had forgotten to send an invoice to a publication, prepared it, and sent it after receiving confirmation. This is where an important line is drawn. A classic ChatGPT would not have “noticed” the forgotten invoice unless the person had opened the chat themselves and asked it to check. An agent-based system must perceive the context on its own, remember the goal, and determine when action is needed.

In other words, OpenAI is essentially trying to make AI not just a place people turn to for help, but a background participant in their work.

Having a Dedicated Computer for AI Changes Much More Than It Seems

One of the most important features of Dots is its own cloud-based computer. To the user, this may sound like a technical detail, but it is precisely this feature that distinguishes a language model from a full-fledged agent.

A typical model can write instructions on how to perform a specific task. An agent with a computer can try to carry it out on its own. OpenAI notes that Dots can use its own browser, connected apps, and work on multiple projects at once. At any time, a user can open the agent’s computer and see what it’s doing.

The same concept is now being extended to the developer platform. The updated Agents API supports “Computer Use,” allowing an agent to use a browser, navigate between pages, and interact with application interfaces. This is fundamentally different from a situation where a language model simply returns text or a structured response via the API.

For example, a company can create an agent that receives a customer request, finds information in the internal system, checks the order status, opens the necessary service, and prepares the next action. Or an agent that analyzes an application, gathers the necessary documents, and forwards the prepared case to a human.

In fact, the same digital workspace in which a human works is gradually opening up to AI: a browser, files, corporate applications, a terminal, and external services.

The more of these tools the model gains, the less important its ability to simply provide polished responses in a chat becomes. Another question takes center stage: Can it correctly understand the task, break it down into steps, use the necessary applications, verify its own work, and recognize when to consult a human?

Codex demonstrates how AI is gradually transitioning from providing hints to actually performing tasks

This transition is most evident in programming. Until recently, AI was primarily an assistant to developers: you could ask it to write a code snippet, find a bug, or explain why a certain function wasn’t working. The human remained the primary operator—opening files, running commands, checking the results, and giving the model the next task.

With Codex, OpenAI is gradually trying to change this very model. At DevDay, the company demonstrated new capabilities that allow developers to assign not just a single operation to the agent, but a much larger chunk of work.

Codex can operate in a cloud environment with access to the repository, necessary dependencies, and tools. The developer sets a task, after which the agent analyzes the project on its own, locates the necessary files, makes changes, runs tests, and returns the result. At the same time, the work isn’t tied to a window open on the computer: the task can continue to run in the cloud even if the user has switched to another task or closed their laptop.

OpenAI’s documentation notes that separate, isolated environments are created for such tasks. This allows Codex to work with the code regardless of the device from which the user submitted the task.

More importantly, work can now be distributed among multiple agents. The Codex CLI now includes tools for parallel task execution: one agent can be tasked with finding the cause of an error, another with working on a specific function, and a third with reviewing changes. In this setup, the user is increasingly shifting from directly writing each command to managing the process.

The same is evident in the example of code review. Codex is capable of analyzing changes, identifying potential issues, and generating feedback even before the developer begins reviewing each file. Certain security tools can also regularly scan repositories, search for vulnerabilities, and suggest fixes.

This does not mean, however, that the programmer can be completely removed from the process. A person still needs to properly formulate the task, define access limits, evaluate the proposed changes, and review mission-critical code.

However, the nature of the interaction itself is changing. Previously, developers used AI primarily to perform individual tasks more quickly. Now, OpenAI is trying to make Codex a system to which an entire task can be delegated: describe the problem, grant access to the project, and, after a certain amount of time, receive a ready-made result.

That is precisely why Codex is a good example of OpenAI’s broader strategy. AI is gradually shifting from the role of a tool that tells a person what to do next to that of an agent capable of covering a significant portion of the path from the assigned task to the final result on its own.

A single agent performs a task; multiple agents can divide the work among themselves

Another fundamental change is the shift from a single model to a system of agents. In the classic ChatGPT, the user was essentially communicating with a single interlocutor. But complex real-world work rarely consists of a single operation.

For example, launching a new product may require competitor research, data analysis, copywriting, code development, security testing, and presentation preparation. OpenAI is gradually building an architecture in which the main agent can use tools and connect other agents for specific parts of the work.

The Agents API already includes mechanisms for managing sessions, context, tools, code execution, and resuming long-running tasks. At DevDay, OpenAI added support for computer usage, multi-agent collaboration, and tool discovery to this system.

This brings AI closer to a kind of digital team. One agent can gather information, another can work with code, and a third can verify the result. Meanwhile, the human can remain focused on defining the task and making the final decision.

OpenAI itself says that it envisions not just a single Dot in the future, but teams of agents working together on behalf of the user.

If this approach becomes sufficiently reliable, the key skill in working with AI may no longer be the ability to correctly formulate a single prompt, but rather the ability to set the right goals, define constraints, and establish a control process.

Plugins in ChatGPT are becoming not just add-ons, but a separate layer of the interface

OpenAI dedicated a separate session at DevDay to how third-party services can operate within ChatGPT. And here, the change is no less significant than in the case of agents or Codex. Previously, connecting an external service to ChatGPT mostly boiled down to accessing its functions or data. A user would submit a query, the model would reach out to the relevant service, and return the result in the chat. Now, OpenAI wants these integrations to feel much more like full-fledged applications.

At DevDay, the company showcased expanded capabilities for plugins that allow developers to create their own interactive elements within ChatGPT: panels, file views, buttons, forms, and other interface components. In other words, a plugin is no longer limited to the role of an invisible “bridge” between the model and an external service.

It can have its own interface directly within ChatGPT. This is an important change for the ecosystem itself. In other words, the service no longer needs to redirect the user to a separate website or force them to switch between multiple tabs. Part of the interaction can be moved directly into the chat.

For example, instead of receiving only a text response from the AI about a document, the user can open it via a separate view. Instead of a description of the data, they can view an interactive dashboard. Instead of a text command, they can click a button or fill out a form created by the plugin developer.

For OpenAI, this means gradually expanding ChatGPT beyond the scope of a typical conversation. The chat remains the entry point, but the actual work within it should be less and less limited to exchanging messages. For third-party companies, this model also opens up a new opportunity: to create a standalone product not just as a website or mobile app, but as a service that lives within ChatGPT and uses it as a ready-made interface for interacting with the user.

If this approach takes hold, ChatGPT may gradually become, for some services, not just a channel for accessing AI, but the platform itself, within which users interact with their products.

OpenAI is preparing ChatGPT for the era of autonomous operation 

If you piece together all the DevDay announcements into a single picture, it becomes clear that OpenAI is gradually changing the very principle of how ChatGPT works. It’s no longer just about improving responses, faster models, or new individual features. The company is building a system to which users will be able to delegate an ever-increasing portion of their work entirely.

In this model, the user doesn’t have to constantly manage every subsequent step. Instead of issuing dozens of individual commands, they formulate a task, define access limits, and receive a result when the work is complete or when the system needs a decision.

It is this concept that brings together the agents presented at DevDay, the Codex cloud service, Computer Use, the Agents API, and a new approach to plugins. Each of these tools solves a specific problem, but together they enable AI not just to respond to a request, but to interact with a real digital environment.

At the same time, this makes the issue of control far more important than before. The problem of model hallucinations isn’t going away. A mistake by a regular chatbot might result in an incorrect answer. A mistake by an agent that has access to files, a browser, email, corporate services, or code could potentially have real-world consequences.

That’s why OpenAI is currently building its agent model around a system of permissions and approvals. Users can specify which actions the AI is allowed to perform on its own, which require approval, and which it should not have access to at all. This will likely become one of the key questions in the next stage of AI development: not just how much the system is capable of doing, but how much it should be allowed to do on its own.

DevDay 2026 showed that OpenAI envisions ChatGPT’s future precisely in this direction. And if this model proves reliable enough, it won’t just be ChatGPT that changes. The very role of the person at the computer will change: instead of constantly performing minor tasks, they will increasingly set goals, define rules, and review completed work.