OpenAI Dots Release: Architecture, Models & Deep Dive

Deep-dive: OpenAI Dots Release: Deep Dive Into Always-On Agents, Cloud VMs, and 4,000 App Integrations

Not as an incremental chat completion endpoint, not as a revised system card, and not as a decorative interface skin, OpenAI unveiled Dots at DevDay 2026. Instead, the release establishes persistent software agents designed to run around the clock inside dedicated cloud virtual machines.

TLDR OpenAI Dots shift ChatGPT from an ephemeral query-response engine into an always-on background worker running on GPT-6 Astra. Each Dot operates inside an isolated cloud virtual machine, connects to over 4,000 tools, and performs read-only background surveillance called Proactive Research. Supported across desktop, mobile widgets, and SMS channels, the system pairs with new developer models like GPT-6.1 Sol while introducing strict action approval gates for real-world execution.

Key Takeaways

• Dedicated Cloud VMs: Every Dot operates on an isolated cloud computer and web browser instance, allowing operations to proceed uninterrupted when local devices disconnect.
• Frontier Backbone: The system runs on the GPT-6 Astra model, supported in developer workflows by the newly shipped GPT-6.1 Sol at a fifth of Astra's token price.
• Broad Tool Reach: Dots integrate with more than 4,000 plugins and enterprise applications across Slack, Microsoft Teams, and cloud services.
• Safety via Proactive Research: Background surveillance operates in a read-only mode, enforcing mandatory user sign-offs for state-altering actions, messages, and code merges.
• Progressive Interface Expansion: Access originated on desktop browsers and rapidly expanded across iOS and Android apps, home screen widgets, and an iMessage/RCS messaging preview.

What Was Actually Shipped: Rollout Timeline and Hardware Sandbox

At Fort Mason in San Francisco during DevDay 2026, OpenAI officially introduced Dots as persistent autonomous assistants. Chief Executive Sam Altman framed the release around executive delegation, likening a Dot to a high-agency engineer or a chief of staff. Product demonstrations led by Holly showcased agents executing long-horizon assignments without continuous interactive prompting.

According to the official announcement documented in the OpenAI release statement, each Dot receives an independent cloud virtual machine and a dedicated browser instance. This setup decouples execution from the user's personal hardware. Rather than pausing execution when a browser tab closes, the agent persists in the cloud, pursuing objectives, logging execution traces, and awaiting approval checkpoints.

Source: @Mr_Salio

The commercial rollout commenced across ChatGPT Pro, Business Premium, and Enterprise workspaces. Initial distribution proved selective. As reported in community breakdowns by testingcatalog, Pro subscribers on tiers ranging from $100 to $500 per month gained access in eligible jurisdictions. European territories, including the European Economic Area, the United Kingdom, and Switzerland, were excluded at launch. Subsequent updates indicated enterprise access expansion into the European Union, while broader consumer availability remained pending.

To facilitate adoption, OpenAI configured the initial launch month to exclude Dots from standard subscription usage quotas. Users begin with a single primary Dot that they can personalize and assign a distinct name. Plans for multi-agent swarms remain slated for future deployment phases.

Architecture and Operating Mechanics: Cloud VM, Proactive Research, and Sandboxed Action

The technical architecture of Dots departs from conventional conversational wrappers. Instead of generating text responses within a short inference window, a Dot functions as an orchestrator across a virtualized computing stack. It combines long-term memory, external tool calling, and autonomous decision loops.

A central architectural pillar is the background monitoring engine. Proactive Research is a background execution cycle where the agent inspects connected software in a sandboxed, read-only mode without manual intervention. While an operator attends to other responsibilities, the agent evaluates incoming data streams across connected channels. When an issue emerges, such as an unresolved bug reported in Slack or an unpaid invoice, the Dot independently scopes the remediation steps.

+--------------------------------------------------------------------------+
|                              USER CHANNELS                               |
|       ChatGPT Web / Mobile  |  Slack & Teams  |  iMessage / RCS SMS      |
+------------------------------------+-------------------------------------+
                                     |
                                     v
+--------------------------------------------------------------------------+
|                         OPENAI DOTS CONTROL PLANE                        |
|                                                                          |
|   +-----------------------+                    +---------------------+   |
|   |   GPT-6 Astra Model   |<------------------>|  Long-Term Memory   |   |
|   +-----------+-----------+                    +---------------------+   |
|               |                                                          |
|               v                                                          |
|   +-----------------------+                    +---------------------+   |
|   |  Proactive Research   |                    |    Action Review    |   |
|   |  (Read-Only Sentinel) |                    |  (Governance Gate)  |   |
|   +-----------+-----------+                    +----------+----------+   |
+---------------|-------------------------------------------|--------------+
                |                                           |
                v                                           v
+-------------------------------+           +------------------------------+
|       VIRTUAL APPLIANCE       |           |      EXTERNAL SERVICES       |
|  - Dedicated Cloud VM         |           |  - 4,000+ App Ecosystem      |
|  - Sandboxed Browser          |           |  - Microsoft Agent 365       |
|  - Local/Cloud Codex Runners  |           |  - Git Pull Requests & APIs  |
+-------------------------------+           +------------------------------+

Security and permissions govern every state change. As detailed in the OpenAI getting started guide, the architecture implements an Action Review protocol supported by configurable Custom Rules. Operations partition cleanly across security boundaries:

• Read-Only Inspection: In Proactive Research mode, tools cannot send messages, alter database records, or modify configuration files.
• Automated Action Screening: Actions that post comments, deploy software, or modify records trigger automated security filters before executing.
• Mandatory Approval Gates: Destructive operations or credential modifications halt execution, pinging the operator for explicit clearance.
• Host Isolation: The cloud VM operates entirely isolated from the user's personal workstation unless the operator explicitly grants remote bridging rights.

Technical analysis from Rohan Paul notes that credential management relies on secure password storage, keeping credentials hidden from model weights. This structure provides programmatic autonomy while preserving operational boundaries.

Ecosystem Synergies: GPT-6 Astra, GPT-6.1 Sol, and Codex Integration

Dots do not operate in isolation. Their release coincided with broader developer infrastructure rollouts at DevDay 2026, anchored by specialized model tiers and expanded developer tooling.

The underlying execution engine powering Dots is GPT-6 Astra, positioned by OpenAI as its most capable reasoning model. For developers managing high-volume programmatic execution, running full Astra inference for continuous background monitoring can introduce significant cost constraints. To address this balance, OpenAI introduced companion models to calibrate performance against inference budgets.

Source: @AGTPinsights

Developers tracking the broader ecosystem can evaluate GPT-6 Astra to assess its core reasoning performance against high-capacity agent baselines. Alongside Astra, OpenAI introduced GPT-6.1 Sol to establish an economical high-tier tier for structured tasks.

At a fifth of Astra's price, GPT-6.1 Sol delivers comparable DeepSWE coding performance while dropping standard token costs to $2 per million input and $10 per million output. Cached input tokens drop further to $0.10 per million, representing a 95% discount over uncached processing. Simultaneously, OpenAI adjusted its lightweight Luna model down to 10 cents per million input and 50 cents per million output tokens, while rolling out an Ultrafast speed tier achieving roughly 300 tokens per second inside Codex.

Model / Tier	Target Workload	Input Price (per 1M)	Output Price (per 1M)	Key Architecture Highlight
GPT-6 Astra	Complex reasoning & Dot core	Premium baseline	Premium baseline	Powers primary autonomous VM agents
GPT-6.1 Sol	High-volume coding & operations	$2.00 ($0.10 cached)	$10.00	Matches Astra on DeepSWE benchmarks
GPT-6 Luna	Low-latency utility & routing	$0.10	$0.50	Ultra-lightweight system orchestration
Ultrafast Tier	Interactive terminal programming	Plan-gated (Pro 500)	Plan-gated (Pro 500)	Up to 8× faster token delivery (~300 tok/s)

Integration with OpenAI Codex expands the agent's utility for engineering teams. A Dot can interact with both cloud and local Codex workspaces, inspect worktrees, analyze historical bug reports, and synthesize code fixes into structured pull requests complete with attached verification videos. Desktop Codex environments also introduced Composer predictions, anticipating subsequent prompt directives without consuming additional quota allocations.

Cross-Surface Expansion: From Desktop Web to iOS Widgets, iMessage, and RCS

Although Dots debuted as a desktop-centric environment, OpenAI methodically broadened access surfaces across a focused 28-day product sprint. Early users were initially required to configure their primary Dot through desktop browsers or desktop application clients before accessing them on mobile interfaces.

Day 5 of the sprint eliminated this restriction, allowing direct agent configuration and interaction on iOS and Android applications. As detailed in coverage by The Verge, this shift transformed the agent from an isolated browser tool into a pervasive personal companion.

Subsequent releases integrated mobile operating system primitives. The official ChatGPT product team update introduced interactive widgets for iOS home screens, providing one-tap access to voice calls and active task threads. Soon after, OpenAI rolled out an SMS preview for United States Pro subscribers, enabling bidirectional communication through Apple iMessage and RCS on Android.

Using native phone messaging, operators can dispatch photos, voice recordings, and text updates directly to their Dot. The agent investigates requests in its cloud VM and pushes proactive progress notifications back into the conversation. For enterprise deployments, integration with Microsoft Agent 365 allows IT administrators to provision specialist Dots equipped with centralized audit logging and governance controls.

OpenAI Dots vs Grok Bot: What the Reports Show

The debut of Dots immediately catalyzed comparisons across competitive autonomous agent frameworks. Industry analysis by WIRED situated the release directly against Meta Muse and xAI's Grok Bot. Competitive friction escalated when xAI directed web traffic from dot.com to the Grok Bot application installation portal.

Public specifications reveal contrasting approaches to autonomous workload management:

• Host Execution Environment: OpenAI Dots run within a sandboxed cloud virtual machine complete with an isolated browser and optional bridged local access. Grok Bot provides dedicated computer execution that signs into user desktop tools, running continuously whether host hardware is awake or suspended.
• Ecosystem Tool Connectivity: Dots leverage ChatGPT's catalog of over 4,000 plugins alongside deep integrations with Slack, Teams, and Codex environments. Grok Bot relies on direct application sign-in connectors, web navigation, and routines configured through demonstration workflows.
• Entry Subscription Pricing: Dots are included within ChatGPT Pro ($100 to $500 monthly) and Business Premium subscriptions without immediate token usage drawdowns. Grok Bot integrates across Cursor subscription tiers, SuperGrok Plus and Heavy packages, and Cursor Teams environments.
• Multi-Agent Coordination: OpenAI confines active users to a single primary Dot at launch, reserving collaborative teams for upcoming iterations. Grok Bot allows operators to instantiate multiple specialized bots concurrently, delegating tasks across parallel threads such as Sales Outbound, Expense Management, and Bug Reproduction.
• Standardized Task Benchmarks: unverified — no public number from either lab yet. While community commentary describes both frameworks as significant upgrades in agentic execution, neither organization has published verified side-by-side benchmark evaluations on standardized benchmarks.

The structural divide centers on multi-agent execution. While Grok Bot emphasizes parallel multi-bot task handoffs from day one, OpenAI prioritizes deep ecosystem integration, leveraging enterprise connections and multi-channel messaging surfaces.

What We Know vs. What We Don't

Separating verified architectural facts from speculative assumptions is essential when planning production infrastructure around autonomous agents.

What this tells us:

• Dedicated Cloud Compute: Dots operate inside isolated virtual machines equipped with cloud-hosted browsers, enabling continuous execution regardless of whether client devices remain online.
• Broad Ecosystem Access: Agents connect across more than 4,000 tools through the established ChatGPT plugin framework and enterprise Microsoft Agent 365 integrations.
• Read-Only Background Monitoring: Proactive Research operates under strict read-only constraints, safeguarding connected data sources while the agent watches for actionable triggers.
• Grace Period Quotas: Access rolled out across Pro, Business Premium, and Enterprise tiers without drawing down baseline token limits during the initial month of availability.
• Multimodal Channel Reach: The interface fabric spans desktop applications, native iOS and Android environments, dedicated lock-screen widgets, and an iMessage/RCS messaging preview for US Pro users.

What it doesn't:

• Autonomous Task Reliability: Standardized task completion percentages, long-horizon bug resolution rates, and SWE-bench Verified metrics for Dots remain unpublished by OpenAI.
• Virtual Hardware Ceilings: Specific compute allocations, virtual CPU limits, memory constraints, and browser rendering sandboxes powering each cloud VM remain unverified.
• Consumer Tier Timeline: Rollout schedules for free or lower-priced Plus plans remain unconfirmed, alongside timelines for expanding SMS messaging outside the United States.
• Multi-Agent Team Operations: Collaborative multi-agent team features remain unreleased, restricting current deployments to a single primary agent per user.
• Post-Grace Usage Pricing: Commercial token pricing structures and rate limits governing background cloud computation once the first-month evaluation window concludes remain unannounced.

On the limited evidence so far, OpenAI Dots appear to shift personal assistants from passive prompt-response loops to persistent background workers, but whether sandboxed cloud environments can prevent prompt injection drifts remains unverified.

Practical Implications for AI Builders

The introduction of always-on cloud agents necessitates adjustments for engineering teams building autonomous workflows.

First, systems require explicit separation between inspection and modification. Engineering architectures should mirror OpenAI's split between read-only Proactive Research and gated Action Reviews. Tool integrations should default to unprivileged read access for environmental monitoring, reserving state changes for human-in-the-loop approvals.

Second, infrastructure planning must address asynchronous agent interactions. As autonomous agents operate through external channels such as Slack, Teams, and SMS, enterprise APIs must support asynchronous callbacks, idempotent task execution, and robust deduplication. Long-running tasks will inevitably encounter transient network interruptions across virtual machines, making resilient state recovery essential.

Finally, development teams must balance intelligence requirements against operational inference costs. Deploying models like GPT-6 Astra for repetitive polling creates unnecessary overhead. Where feasible, pipelines should offload routine processing to cost-efficient models such as GPT-6.1 Sol, invoking premium models only when complex reasoning demands it.

What to Watch Next

As autonomous agents transition into real-world production workflows, builders should track three critical operational signals:

1. Watch official technical documentation: Monitor whether OpenAI publishes comprehensive system cards detailing task completion rates, sandbox escape mitigations, and context-window degradation during prolonged sessions.
2. Run internal isolation audits: Evaluate how effectively sandboxed cloud computers protect against indirect prompt injections encountered across third-party websites or connected enterprise messaging boards.
3. Pin commercial rate schedules: Track updates regarding how OpenAI prices continuous background compute once introductory zero-drawdown grace periods expire across Pro and Enterprise workspaces.

Try related models on Kie.ai: GPT-6 Astra, GPT 6.1 Sol and OpenAI Codex.