Inside OpenAI DevDay: Superhuman Computer Use, Decisions API, and the AI Cloud — Ari & Nikunj

Summary

• OpenAI argues computer use has crossed from brittle demos into useful labor, responding to a claim from a leading AI podcast that it had not advanced in two years. Ari Weinstein says agents are now “faster at accomplishing tasks than the average human probably in most cases,” in part because they can debug, retry, and introspect instead of merely starting tasks successfully.
• The economic unlock is improving faster than headline model pricing suggests. GPT-6.1 Soul was presented as one-fifth the cost of Astra overall and one-seventh the cost for computer use specifically. The host also cited a keynote claim of a 7× improvement in computer-use speed. That shifts the investable bottleneck from raw intelligence toward inference, harness design, and software response times.
• Dots turns computer use into general-purpose delegation by giving each Dot its own Linux cloud computer. The addressable surface is effectively any human-facing software, including services with poor APIs: Ari’s meal order fell from two hours manually to 15 minutes, while the hosts highlighted flight booking, customer support, YouTube operations, games, and shopping.
• OpenAI’s Decisions API responds to Jev and shows how quickly a new AI product category can be absorbed by a frontier lab. Nikunj Handa said it was “not at all” on the table four weeks earlier; user requests and internal teams prompted inference and infrastructure engineers to build a prototype, after which the project moved into latency hill-climbing. The first version uses Luna’s existing weights rather than a new model.
• Computer use is increasingly a multimodal systems problem, not a screenshot-clicking benchmark. Agents can combine screenshots, accessibility data, Playwright, direct DOM access, and generated JavaScript that performs multiple actions at once; AppShot similarly exposes underlying metadata rather than pixels alone. “A lot of little paper cuts” now matter as much as isolated model gains.
• The Agents API creates a distribution advantage because OpenAI trains models on the same computer-use harness developers can use. Ari says that may improve “speed and cost and accuracy,” while autonomous testing closes the software-development loop: an agent can build and test an application before a human becomes QA.
• The platform roadmap is converging on an AI-native cloud built around asynchronous execution, caching, and context management. WebSockets enable mid-turn steering and async tool calls; cache guarantees are available within 30 minutes, while a 12-hour guarantee is in preview and not yet public. Pre-warming and cheaper reads are also being developed. The unresolved question is how much memory, storage, and agent structure OpenAI should abstract versus leave flexible.

Deep dive

1. Computer use has advanced 180 degrees, not stood still

• The hosts invoke a claim from a leading AI podcast that computer use had not advanced in two years; Ari’s blunt rebuttal is that it is now “180 degrees different.” The meaningful comparison is less with last week’s release than with the cumulative jump over the past one or two months.

• A year ago, models could “reliably start tasks” but would derail when something unexpected happened. Ari identifies the decisive capability gain as debugging: current models try again, inspect what failed, and alter their approach, allowing them to complete longer workflows rather than merely demonstrate a plausible first action.

• The keynote’s stack included Dots, GPT-6.1 Soul, computer use inside the Agents API, AppShot, native Mac control, and the Decisions API. GPT-6.1 Soul was described as one-fifth the cost of Astra generally and one-seventh the cost on computer-use workloads.

2. The harness now sees structure and writes actions in batches

• Ari’s framing: modern computer use does not depend on a single interface. Depending on the task, the model may combine screenshots, accessibility representations, Playwright, and direct DOM access, then write JavaScript that executes many operations instead of clicking through one action at a time.

• The concrete breakthrough is eliminating repeated screenshot-scroll cycles. When an agent can inspect an entire page or application structurally, it can locate content beyond the viewport and manipulate multiple elements at once; Ari calls added modalities one of the field’s biggest “aha moments.”

• AppShot illustrates the distinction. Double-tapping the Command keys may appear to attach a screenshot, but it also supplies token-efficient accessibility metadata: link destinations that pixels cannot reveal, full calendar titles hidden by truncation, and the raw text representation available behind the attachment.

• Ari resists attributing gains to one magic change: production products use different safety configurations, while improvements arrive from models, inference, representations, and harness engineering. The speed curve is increasingly moved by “a lot of little paper cuts” found through detailed introspection.

3. Dots makes every piece of human software addressable

• Each Dot has its own Linux virtual computer in the cloud, capable of running desktop applications as well as a browser. Ari’s core thesis is universality: because “all the software in the world was designed for humans,” an agent that can operate human interfaces can accept nearly any computer-bound task.

• His sharpest personal example is a customizable meal-prep service. Specifying exact grams of chicken and rice took him two hours; computer use completed the same order in 15 minutes—“eight times faster”—on GPT-6.1 Soul.

• The host extends that logic to surfaces neglected by APIs. YouTube workflows such as A/B testing and community posts still require UI operation, while the host described customer-service workflows that can wait, research with subagents, supply reference numbers, and continue negotiating without consuming the user’s attention.

• This lowers what Ari calls the “activation energy” of delegation: once agents become fast enough, users may default to assigning work they currently do manually. What proves valuable will still depend heavily on the individual user rather than a universal killer workflow.

4. Superhuman speed now depends partly on the software being operated

• Ari says computer use is already “faster at accomplishing tasks than the average human probably in most cases.” The next frontier is narrower: become as fast or faster than expert computer users, enabling genuinely real-time products rather than merely asynchronous task completion.

• As inference accelerates, external applications become the bottleneck. A meaningful share of a DoorDash benchmark can be spent waiting for DoorDash itself to load; the system must then minimize the delay between completion of that load and the model’s next action.

• Event-driven triggers solve some waits, such as browser navigation events, but not every state transition can expose a clean event. Customer-support replies that arrive anywhere from 30 seconds to three minutes exemplify the scheduling problem still hiding beneath apparently simple automation.

5. Trust and autonomous QA determine whether universality compounds

• The host describes how quickly his own trust frontier moved: three or four years ago, connecting LLMs to devices and the web felt dangerous; now he lets Codex configure DNS, pay bills, and handle “tens of thousands of dollars” of activity while “YOLOing with computer use.”

• Ari’s counterweight is progressive trust, not unrestricted autonomy. Reliable systems should request consent before consequential actions such as payments and, depending on the application, restrict access to only the websites and applications needed for the assigned task.

• For developers, OpenAI’s computer-use harness offers more than convenience because the models train against it. Ari says staying in-distribution “might be a speed and cost and accuracy advantage,” though developers can still build their own harnesses when they need specialized control.

• His favorite coding workflow lets an agent test what it built. Computer use closes the lifecycle from implementation through testing and inspection, removing the pattern where “you are now QA for the agent”; Ari sometimes even has one computer-use agent test another.

6. Jev inspired a category, and OpenAI responded with Luna

• Nikunj gives Jev explicit credit for “inspiring a whole segment in the market.” He says that four weeks earlier the Decisions API was not on the table; user requests and internal teams prompted inference and infrastructure engineers to build a prototype, after which the project moved into latency hill-climbing.

• The initial Decisions API is not a newly trained model. It constrains the existing Luna weights through structured outputs, runs multiple questions in parallel as a batch, and optimizes the inference stack for fast time to first token and time between tokens; Luna’s vision capability comes along “for free.”

• Its clearest use is fast classification, including support-ticket classification. Low-latency LLM-as-a-judge evaluation and computer-use or GPT Live demos were also discussed, but Nikunj preserves the limitation: a non-reasoning Luna choosing one action at a time will not match Astra writing a JavaScript program for sophisticated, long-horizon computer use.

• Vibhu frames an unresolved differentiator as calibrated confidence, arguing that RLHF can push a model toward what users want to hear without necessarily preserving the right confidence level. Nikunj agrees calibration may be an area OpenAI must “hill climb” through future model releases.

7. OpenAI is assembling the primitives of an AI-native cloud

• GPT-6’s API additions include asynchronous function calling and mid-turn steering: a model can launch a slow tool, keep reasoning, and accept new instructions when results arrive. WebSockets supply the bidirectional channel, reducing tool-call overhead for agentic execution and Ultrafast inference.

• Nikunj credits inference work first with cutting Luna’s price by roughly 80%, then with pushing Astra toward “frontier intelligence at extreme speeds.” GPT Live can act as a fast talker and delegator with Astra behind it, while Decisions API and Luna make rapid tool-calling demos feel snappier.

• Responses API performance now extends beyond token generation. OpenAI guarantees cache hits within 30 minutes, is previewing a 12-hour guarantee for one user, and supports pre-warming so developers can pay the cache-write cost before traffic arrives and reuse the prompt across multiple thread instances.

• Context still requires compression despite caching. Agents API includes proprietary compaction; Responses API offers threshold-based server compaction or manual /compact, while file-based techniques are implemented and being experimented with in the Codex harness. Nikunj’s open design question is whether future memory vaults and storage concepts should become high-level primitives or remain examples developers assemble themselves.