OpenAI DevDay 2026: Dots, GPT-6.1 Sol, and the Agents API — The Complete Guide for Agentic AI Architects

On September 29, 2026, Sam Altman walked onstage at OpenAI DevDay and announced something that should make every automation architect recalibrate: OpenAI is no longer building a chatbot. It is building an agent operating layer — a persistent, always-on infrastructure where AI agents run on their own cloud computers, orchestrate sub-agents, connect to 4,000+ applications, and keep working while you sleep. The centerpiece is Dots, OpenAI’s always-on personal agent platform. Backing it up is GPT-6.1 Sol, a model that matches GPT-6 Astra’s coding performance at one-fifth the cost, and a public-beta Agents API that gives developers managed sessions, multi-agent orchestration, and computer-use capabilities out of the box.

For RPA teams, the implications are immediate. The workflows you currently build with screen scraping, attended bots, and scheduled triggers now have a competitor that runs 24/7 on a cloud VM, uses a browser the way a human does, and costs roughly $0.72 per task. This guide breaks down every DevDay 2026 announcement that matters for agentic AI architects, with pricing, benchmarks, architecture details, and a clear-eyed assessment of where OpenAI’s agent stack fits — and where it does not — in the enterprise automation landscape.

What OpenAI Actually Announced: The Full DevDay 2026 Stack

DevDay 2026 was not a single product launch — it was the unveiling of an integrated agent ecosystem. Understanding the pieces and how they connect is the first step to deciding which ones belong in your architecture.

Dots: Always-On Personal Agents

Dots are persistent AI agents powered by GPT-6 Astra. Unlike a ChatGPT conversation that ends when you close the tab, a Dot runs continuously on its own cloud computer with browser access and connections to over 4,000 applications through OpenAI’s plugin ecosystem. Each Dot maintains context across sessions, learns from your feedback, and can delegate work to sub-agents.

The key capabilities that matter for automation professionals:

Availability: Dots are rolling out to ChatGPT Pro, Business Premium, and Enterprise users. Enterprise and Education plans have Dots disabled by default, with admin-controlled enablement. Critically, Dots do not count toward ChatGPT usage limits — they run on separate compute allocation.

For RPA architects accustomed to UiPath Orchestrator or Automation Anywhere’s Control Room, the mental model is straightforward: a Dot is an unattended bot with an LLM brain instead of a flowchart. The critical difference is that Dots reason about what to do, not just how to execute a pre-defined sequence. That makes them powerful for unstructured tasks but introduces the same trust-and-verification challenges that every enterprise faces when moving from deterministic to probabilistic automation.

GPT-6.1 Sol: The Cost Equation That Changes Agent Economics

If Dots are the “what,” GPT-6.1 Sol is the “how much.” This model is purpose-built for agentic workloads — coding, computer use, and repeated task execution — and it changes the cost equation dramatically.

More Read

Pydantic AI v2 Capabilities: The Complete Guide to Composable Agent Architecture (2026)

Unlocking CrewAI Knowledge Feature: A Practical Guide with Examples

LangGraph vs. CrewAI vs. Microsoft Agent Framework vs. Google ADK: Which Multi-Agent Framework Should You Actually Learn in 2026?

Benchmark Performance: Where Sol Matches Astra and Where It Does Not

The benchmark numbers tell a nuanced story. On coding and agentic tasks — the workloads that matter most for automation — Sol performs at or above Astra’s level:

The takeaway for architects: GPT-6.1 Sol is the model you should default to for agentic workloads. Reserve Astra for the most demanding scientific or research tasks where the extra 0.84 Intelligence Index points justify a 5x price premium. For automation pipelines processing invoices, reconciling data, or orchestrating multi-step business workflows, Sol delivers the performance you need at a price point that makes agent-per-task economics viable at enterprise scale.

Sol also supports five reasoning effort levels — low, medium (default), high, xhigh, and max — giving you fine-grained control over the cost-accuracy tradeoff. An invoice-extraction agent running at low effort costs a fraction of a document-analysis agent running at max, and you can tune per task type.

Agents API: The Infrastructure Layer for Custom Agent Development

While Dots serve end users directly, the Agents API (now in public beta) is the developer-facing infrastructure for building custom agentic applications. This is what matters most if you are an agentic AI architect building production systems rather than using ChatGPT’s consumer interface.

The Agents API provides:

• Managed sessions: OpenAI handles session persistence, state management, and recovery — you do not need to build your own context-management layer
• Multi-agent orchestration: Native support for spawning, coordinating, and aggregating results from multiple agents working in parallel
• Computer-use capabilities: Agents can interact directly with software interfaces through OpenAI-hosted browsers — screen scraping and UI automation without maintaining your own browser infrastructure
• Tool search: Dynamic discovery and invocation of tools from the plugin ecosystem, so agents can find and use the right integration at runtime
• Context compaction: Automatic management of the context window for long-running agent sessions, preventing the token-limit cliff that kills naive agent implementations

Performance improvements over the previous API generation:

• 45% reduction in time to first token
• 30% faster tool calls and workflow execution
• 99%+ reliability (measurement period unspecified by OpenAI)
• 100x usage growth year-over-year across the API

The Agents API also integrates with AWS Bedrock, meaning you can run OpenAI models within AWS’s managed infrastructure — relevant for enterprises with existing AWS commitments. For architects who have been evaluating Microsoft’s Agent Framework or building on LangGraph/CrewAI, the Agents API is now a direct competitor that bundles orchestration, compute, and model access into a single managed service.

Decisions API: Fast Routing for Agent Pipelines

The Decisions API is the quieter announcement that may matter the most for high-throughput automation. Built on GPT-6 Luna, it handles classification, routing, and constrained-choice decisions at 10x the speed of a full model call — without generating explanatory text. Think of it as the “triage agent” at the front of your pipeline.

Use cases for automation architects:

• Intent routing: Classify incoming requests and route to the correct specialist agent in milliseconds
• Document classification: Sort incoming documents (invoices, purchase orders, contracts) before sending to processing agents
• Action selection: Choose the next step in a multi-step workflow from a predefined set of options without the latency of full model reasoning
• Escalation decisions: Determine whether an agent’s output needs human review based on confidence scoring

Status: limited preview, with broader availability expected in the coming weeks.

Codex Cloud and Security Cloud: The Developer Tooling Layer

Codex Cloud provides isolated cloud environments where coding tasks run with access to repositories, tools, and dependencies — with tasks continuing even when the developer’s device is inactive. For automation teams, this matters because it enables:

• Continuous code review: Automated diff analysis, summarization, and pre-merge problem identification for automation scripts
• Security scanning: Codex Security Cloud continuously scans repositories for vulnerabilities and prepares automated fixes — critical for RPA codebases that often connect to sensitive enterprise systems
• Cross-device continuity: Start debugging an automation workflow on your laptop, continue on your phone during a commute, finish on a browser at the office

ChatGPT Space and Team Tasks: The Collaboration Layer

ChatGPT Space introduces shared team workspaces that combine people, AI agents, files, and organizational knowledge. For automation teams, the relevant features include:

• Living Pages: Collaborative documents where humans and AI work concurrently — useful for maintaining automation runbooks and design documents
• Team Tasks: Recurring work delegation with schedule or event-triggered automation, managed within the Space
• @ChatGPT for Slack and Teams: Direct integration enabling AI-assisted automation within existing communication workflows
• Meetings Plugin: Automated meeting capture, personalized notes, and action item extraction with audio deletion after processing

Pricing and Plans: What Enterprise Adoption Actually Costs

DevDay 2026 introduced two new premium tiers that reflect OpenAI’s bet on enterprise willingness to pay for agent capabilities:

Ultrafast tier: For GPT-6 Astra, the Ultrafast service tier delivers up to 8x faster token generation (up to 300 tokens per second in Codex, 6x in API) at a 6x price multiplier. GPT-6.1 Sol support is coming later. For latency-sensitive automation pipelines — real-time customer service agents, live document processing — this is the tier that makes sub-second response times achievable.

Private Intelligence: For regulated industries, OpenAI introduced Zero Data Retention with Private Safety Processing (available now) and a Private Inference preview launching fall 2026. This addresses the data-residency and privacy concerns that have blocked AI agent adoption in healthcare, finance, and government — sectors where RPA has historically dominated precisely because bots process data locally.

The Enterprise Ecosystem Play: Marketplace, Sign-In, and Lock-In

Three distribution announcements reveal OpenAI’s broader strategy to become the enterprise agent platform, not just the model provider:

OpenAI Marketplace: Over 30 enterprise partners — including Adobe, Figma, Salesforce, ServiceNow, and Harvey — offer products that enterprises can procure using existing OpenAI spending commitments. This mirrors Salesforce’s AppExchange model: reduce procurement friction by letting enterprises consolidate AI spending.

Sign in with ChatGPT: Sixteen launch partners (including Devin, Notion, and Vercel) can authenticate users via their ChatGPT subscription, with inference costs covered by the user’s existing plan. For builders, this eliminates the need to provision inference infrastructure. For OpenAI, it creates Facebook Login-style network effects — the more apps support it, the stickier ChatGPT subscriptions become. OpenAI reported 1.2 billion weekly active users at DevDay.

Plugin Extensions: Custom sidebar experiences, interactive panels, and file viewers that turn ChatGPT into an extensible platform. Dozens of launch partners including Figma and Photoshop have built plugin extensions, and MCP Events support enables real-time data flow between plugins and agents.

For enterprise architects evaluating the Microsoft Copilot ecosystem versus OpenAI’s emerging stack, this is the strategic comparison that matters: Microsoft bundles agent capabilities into an existing productivity suite (Office 365, Power Platform), while OpenAI is building a new platform from scratch with ChatGPT as the hub. The right choice depends on your organization’s existing investments and appetite for platform migration.

What This Means for RPA Teams: Five Concrete Implications

1. The “Attended Bot” Category Is Being Absorbed

Dots do what attended bots do — assist a human worker with repetitive tasks on their desktop — but without requiring process mapping, flowchart design, or maintenance when the UI changes. For RPA teams maintaining attended automations that frequently break on UI updates, Dots offer a fundamentally different maintenance model: the agent adapts to UI changes through vision and reasoning rather than failing on a missing selector.

This does not mean you should rip out working attended bots. It means you should stop building new attended bots for tasks that involve unstructured judgment, frequent UI changes, or cross-application workflows that are expensive to map deterministically.

2. The Cost Floor for Agent-Per-Task Has Dropped Below RPA

At ~$0.72 per task on GPT-6.1 Sol, the per-transaction cost of an AI agent is now competitive with — and in some cases below — the fully loaded cost of an RPA bot transaction when you account for development time, maintenance, infrastructure, and licensing. This does not apply to high-volume, stable, deterministic processes (invoice data entry from a fixed template, for example) where RPA’s near-zero marginal cost still wins. But for the long tail of medium-volume, semi-structured processes that were too expensive to automate with traditional RPA, the economics now favor agents.

3. Multi-Agent Orchestration Is Now a Managed Service

The Agents API’s built-in orchestration eliminates the need to build your own agent coordination layer using frameworks like LangGraph, CrewAI, or Orca ADE. For teams that have been evaluating these open-source orchestrators, the tradeoff is now managed-service convenience versus open-source flexibility. The Agents API handles session persistence, context compaction, and recovery out of the box — capabilities that require significant engineering effort to implement correctly with open-source tools.

4. Agent Safety and Governance Become Non-Negotiable

Dots running 24/7 with browser access and 4,000+ app connections represent a significant attack surface. OpenAI’s user-controlled boundaries and approval requirements are a start, but enterprise deployments need the kind of comprehensive agent governance frameworks that NVIDIA, IBM, and ServiceNow are building. If you are deploying Dots or any always-on agent in production, your governance stack needs to cover: action-level approval policies, audit logging, data access controls, anomaly detection, and kill switches. The ServiceNow AI Control Tower and similar platforms exist precisely because LLM-powered agents require different governance than deterministic bots.

5. The Hybrid Architecture Is Now the Default

No enterprise will go all-agents or all-RPA. The architecture that emerges from DevDay 2026 is a hybrid stack where:

• Traditional RPA bots handle high-volume, deterministic, stable processes (ERP data entry, report generation from fixed templates, system-to-system API integrations)
• AI agents (Dots, Agents API, or equivalent) handle semi-structured, judgment-heavy, cross-application workflows (email triage, document review, vendor communication, exception handling)
• The Decisions API (or equivalent routing layer) sits at the front, classifying incoming work and routing it to the right execution engine — bot or agent — based on the task type

This is the architecture pattern that the Salesforce Agentforce and Microsoft Copilot ecosystems are also converging on. The vendor you choose matters less than getting the routing layer right.

Architecture Deep Dive: How the DevDay 2026 Stack Fits Together

For architects designing a production deployment, here is how the DevDay 2026 components integrate into a layered system:

Layer 1 — Routing (Decisions API): Incoming requests, documents, and events hit the Decisions API first. Luna-based classification determines whether the task requires full agent reasoning, a deterministic bot, or a human handoff. Decisions execute in milliseconds at 10x the speed of a full model call.

Layer 2 — Agent Runtime (Dots / Agents API): Tasks classified as agent-appropriate enter the agent runtime. Dots handle user-facing, ongoing responsibilities (monitoring, follow-up, recurring work). Custom agents built on the Agents API handle programmatic, API-driven workloads with managed sessions and multi-agent orchestration.

Layer 3 — Model Selection (Sol vs. Astra): GPT-6.1 Sol serves as the default model for agent reasoning at $2/$10 per million tokens. Astra is reserved for tasks requiring maximum intelligence at $10/$50 per million tokens. The reasoning effort parameter (low through max) provides additional cost-accuracy tuning within each model.

Layer 4 — Tool Execution (Plugins + Computer Use): Agents execute actions through the plugin ecosystem (4,000+ app integrations) or computer-use capabilities (OpenAI-hosted browsers for UI automation). This is the layer where agents interact with enterprise systems — CRMs, ERPs, ITSM platforms, and custom internal tools.

Layer 5 — Collaboration (ChatGPT Space): Team workspaces provide the human-in-the-loop interface. Living Pages maintain shared context. Team Tasks manage recurring delegated work. Slack and Teams integrations keep agents accessible within existing communication workflows.

Layer 6 — Governance (Private Intelligence + Admin Controls): Zero Data Retention, Private Safety Processing, and Private Inference provide the data-handling guarantees regulated industries require. Admin-controlled Dot enablement, user-set boundaries, and approval workflows provide the access controls.

Competitive Context: OpenAI vs. the Enterprise Agent Landscape

DevDay 2026 positions OpenAI as a direct competitor to every major enterprise agent platform. Here is how the stack compares on the dimensions that matter for procurement decisions:

The verdict for architects: OpenAI’s stack is the strongest option when you need general-purpose agents with broad application reach and do not have deep existing investments in Microsoft 365 or Salesforce. Microsoft wins when you are already embedded in the M365 ecosystem. Salesforce wins for CRM-centric agent workflows. Open-source wins when you need maximum control, data sovereignty, or customization — at the cost of managing everything yourself.

Production Considerations: What DevDay Did Not Tell You

Every DevDay keynote optimizes for excitement. Here are the production realities that the announcements glossed over:

The 7.7% factual error rate is real. GPT-6.1 Sol at low reasoning effort produces incorrect facts 7.7% of the time. For document-processing agents handling financial data, medical records, or legal documents, that error rate requires a verification layer — human review, cross-referencing against source systems, or a secondary model check. Do not deploy a Sol-powered extraction agent into production without a validation step.

The 4,000+ app integrations are not all equal. Plugin quality varies enormously. Some provide deep, bidirectional integration (Slack, Salesforce). Others are thin wrappers that break when the underlying API changes. Before depending on a specific plugin for a production workflow, test it under load and verify its error handling.

“99%+ reliability” needs a measurement window. OpenAI did not specify the measurement period for the Agents API’s claimed 99%+ reliability. For SLA-driven enterprise deployments, you need your own monitoring and fallback mechanisms. A 1% failure rate at enterprise scale — tens of thousands of agent tasks per day — means dozens of failures daily.

Dots’ learning-from-feedback creates drift risk. Dots improve by learning from user interactions. That is powerful, but it also means a Dot’s behavior can drift over time in ways that are difficult to audit. Enterprise deployments need periodic behavioral auditing — comparing a Dot’s current decision patterns against its initial configuration — to catch unintended drift before it causes errors.

Cost projection requires realistic token estimation. The ~$0.72 per task cost assumes typical token usage. Long-context tasks (processing 50-page contracts, analyzing large codebases) will consume significantly more. Build your cost model on your actual document sizes and task complexity, not on OpenAI’s benchmark averages.

Getting Started: A Practical Migration Path

For RPA teams evaluating the DevDay 2026 stack, here is a low-risk migration path:

Phase 1 — Identify candidates (Week 1-2): Audit your current automation portfolio. Flag processes that meet two or more of these criteria: (a) frequent maintenance due to UI changes, (b) requires human judgment at one or more steps, (c) involves unstructured data (emails, documents, chat messages), (d) spans three or more applications. These are your best candidates for agent migration.

Phase 2 — Pilot with the Agents API (Week 3-6): Build a proof-of-concept using the Agents API with GPT-6.1 Sol for one high-value candidate process. Use the managed session and orchestration features — do not build your own infrastructure at this stage. Measure: accuracy, cost per task, latency, and failure rate against your current RPA implementation.

Phase 3 — Add governance (Week 7-8): Before scaling beyond the pilot, implement your governance layer: approval policies, audit logging, error handling, and human-escalation triggers. If your organization is in a regulated industry, evaluate Private Intelligence for data-handling compliance.

Phase 4 — Hybrid deployment (Month 3+): Deploy the Decisions API (or a custom routing layer) to classify incoming work and route to the appropriate execution engine — existing RPA bots for deterministic tasks, agents for judgment-heavy tasks. Monitor both channels and compare cost-per-outcome, not just cost-per-transaction.

Frequently Asked Questions

How do OpenAI Dots compare to UiPath or Automation Anywhere unattended bots?

Dots and unattended RPA bots solve different problems. Unattended bots execute pre-defined workflows deterministically — they are faster and cheaper for stable, high-volume, structured processes. Dots reason about what to do at each step using LLM intelligence, making them better suited for semi-structured tasks that require judgment, adaptation, and cross-application reasoning. Most enterprises will run both: bots for the predictable work, agents for the unpredictable work.

What does GPT-6.1 Sol cost per transaction compared to RPA?

OpenAI’s benchmark data suggests ~$0.72 per typical task on GPT-6.1 Sol. A traditional RPA bot’s fully loaded cost per transaction — including development amortization, licensing, infrastructure, and maintenance — varies from $0.05 to $2.00 depending on volume and complexity (Everest Group, 2025). For high-volume, simple transactions, RPA is still cheaper. For medium-volume, complex transactions requiring judgment, Sol-powered agents are increasingly competitive.

Can the Agents API replace LangChain or CrewAI for multi-agent orchestration?

The Agents API provides managed orchestration, session persistence, and context compaction that LangChain/LangGraph and CrewAI require you to build yourself. If you want a turnkey managed service and are committed to OpenAI’s model ecosystem, the Agents API is a simpler path. If you need multi-model support (mixing OpenAI, Anthropic, and open-source models), vendor independence, or deep customization, open-source frameworks remain the better choice.

Is it safe to deploy Dots in regulated industries like healthcare or finance?

Not yet without additional controls. OpenAI’s Private Intelligence (Zero Data Retention + Private Safety Processing) is available now, and Private Inference is coming in fall 2026. However, regulated industries need SOC 2 Type II compliance, audit trails, data lineage, and role-based access controls at a granularity that OpenAI’s current governance layer does not fully provide. Expect to layer third-party agent governance tools on top of Dots for regulated deployments.

What happened to GPT-6 Astra — is it still available?

GPT-6 Astra remains available and is still OpenAI’s most capable model. However, OpenAI withdrew the GPT-6.1 Astra variant “due to identified safety failures” (October 1, 2026 announcement). GPT-6.1 Sol is the recommended model for most agentic workloads due to its 5x cost advantage with near-equivalent performance on coding and automation benchmarks.

Key Takeaways

• Dots are always-on personal agents powered by GPT-6 Astra, running on dedicated cloud VMs with browser access and 4,000+ app integrations — the most fully realized “agent-as-a-service” offering from any major vendor to date.
• GPT-6.1 Sol delivers near-Astra coding performance (75.2% on DeepSWE v1.1 vs. Astra’s 74.8%) at one-fifth the cost ($2/$10 per million tokens vs. $10/$50), making agent-per-task economics viable at enterprise scale.
• The Agents API enters public beta with managed sessions, multi-agent orchestration, computer-use capabilities, and context compaction — a direct competitor to LangGraph, CrewAI, and Microsoft’s Agent Framework as managed infrastructure.
• The Decisions API provides millisecond routing for agent pipelines at 10x the speed of full model calls — enabling the triage layer that hybrid RPA/agent architectures require.
• Enterprise governance is the gap. Private Intelligence and admin controls are a start, but regulated industries will need third-party governance platforms (NVIDIA Open Agent Safety Platform, ServiceNow AI Control Tower) layered on top.
• The hybrid architecture is the answer — RPA bots for deterministic high-volume work, AI agents for judgment-heavy semi-structured work, and a routing layer to classify and dispatch. This is the pattern every major vendor is converging on.

References

1. OpenAI DevDay 2026 Keynote Announcements — Business Standard
2. OpenAI DevDay 2026: Dots, GPT-6.1 Sol, Ultrafast, Codex Cloud — BenchLM
3. OpenAI DevDay 2026: The Biggest AI Announcements Explained — Analytics Insight
4. The 5 Announcements That Reveal OpenAI’s Agent Empire Strategy — BestHub.dev
5. GPT-6.1 Sol Complete Guide: Pricing, Benchmarks, API — CodersEra
6. OpenAI Releases GPT-6.1 Sol at a Fifth of GPT-6 Astra’s Token Prices — The Next Web
7. OpenAI DevDay 2026: 20+ Updates Explained — Digital Strategy AI
8. OpenAI’s Agents Reach 10M Users After ChatGPT Work Debut — Crypto Briefing
9. AI Agents News Brief: October 1, 2026 — AI Agents Directory
10. AI Agents News Brief: October 6, 2026 — AI Agents Directory

Last updated: October 7, 2026