The most visible DevDay move was handing agents a computer
At DevDay in San Francisco on September 29, OpenAI launched Dots. The counterintuitive part is not that it is "smarter" but that every Dot instance runs inside its own dedicated cloud Linux virtual machine. Not an embedded browser, not a tether to your local Mac, but a real cloud computer that runs full desktop apps, manipulates a file system, and opens a terminal.
Altman's keynote example was down to earth: migrate an app before a legacy API shuts down. The hard part is that dependencies are scattered across the codebase and it is unclear where changes will break. Dots chases the dependencies, finds everything to change, writes the code, runs the tests, and hands the pull request to the team. It also connects to over 4,000 apps on ChatGPT, inheriting the permissions of the plug-ins you already linked.
The cheap companion model: GPT-6.1 Sol
Behind Dots sits GPT-6.1 Sol, a mid-tier model tuned for computer use. OpenAI says its overall cost is about one-fifth of Astra and drops to one-seventh specifically on computer-use workloads. It carries a 1.05-million-token context and is priced at 2 dollars per million input and 10 dollars per million output, matching Astra's rate but saving where the cheaper model is enough.
The real speed numbers are striking. Weinstein described configuring a complex meal-prep order that took a human two hours; a Dot did it in 15 minutes on Sol, an eightfold speedup. Altman also showed OpenAI's own team using Dots to "fix dozens of bugs a day": it catches feedback in Slack, investigates, and opens the pull request itself.
Three genuinely interesting engineering bits
One is "App Shots," which captures not just a screenshot but the app's raw text and accessibility tree, giving the model a more token-efficient context. Two is the hybrid pipeline: accessibility trees, the DOM, Playwright, and model-generated JavaScript are stacked so the agent can "write one JS snippet to do several steps" instead of clicking the UI one action at a time, which is what drives the speedup.
Three is the Decisions API: a wrapper around the smaller Luna model that drops reasoning for latency, built in a one-week sprint cloning Jev's architecture, aimed at millisecond classification and routing. The cost is that it cannot handle long-horizon reasoning, so it stays separate from the main models.
The boundaries were also spelled out
OpenAI itself admitted the trade-off: the Decisions API's ultra-low latency comes from stripping reasoning, so it cannot catch long-horizon complex tasks and must be deployed separately from persistent multimodal cloud agents. The Agents API opens the same Codex harness as a service, meaning you stop building your own wheel but also hand control to OpenAI's training assumptions.
Permissions and trust were stressed repeatedly: payments and sensitive actions must request user consent, and agents may only reach necessary sites and apps. Persistent does not mean unrestricted.
A persistent environment is a double-edged sword
Each Dot is a never-sleeping cloud Linux VM. The upside is state kept across sessions and work through the night; the cost is that both the compute bill and the attack surface grow linearly with instances. The more apps you connect and the wider the permissions, the larger the blast radius if the account or the Dot is compromised. That is why OpenAI inherits your own scope and asks for confirmation on key actions; the restraint is not fear of use but fear of an uncovered blast.
The self-check loop is what makes it production-ready
The most valuable engineering idea in Dots is letting the agent test the software it just wrote. In the past you were the agent's QA; now it writes code, runs the tests, and inspects screenshots for layout issues itself. This write-execute-verify loop decides whether it reaches production more than a smarter model alone. When you adopt agents, prefer ones that verify their own output over ones that only hand you an answer.
What this means for you
The leap from prototype to production for agents is exactly "a persistent environment plus a self-checking loop" — give it a workstation it can stay in, then let it write code and test it. You can borrow this idea now: hand a long task to an agent with a fixed environment, file access, and the ability to run tests, which saves far more than starting a fresh session every time. But you set the permission boundary; do not let it default to touching everything you own.