OpenAI’s DevDay on September 29, 2026 was not a typical model drop. OpenAI announced several products and features at its DevDay 2026 event, including always-on AI agents called Dots, the GPT-6.1 Sol model, a new ChatGPT collaborative workspace, cloud-based Codex, and new APIs for developers. For developers building production agent systems, openai dots just changed the calculus on a core architectural question: should you build your own agent infrastructure from scratch, or plug into what OpenAI just shipped? This article breaks down what Dots actually is, what the new APIs give you, where the seams are, and how to decide.
What OpenAI Dots Actually Is (And What It Is Not)
OpenAI introduced dots during the DevDay 2026 keynote in San Francisco on September 29. Dots is a personal AI agent built into ChatGPT and powered by GPT-6 Astra. The key word is persistent. Unlike a conventional chatbot that waits for a user to send a message, Dots are designed to remain active and take responsibility for ongoing tasks.
Each agent operates with its own virtual cloud computer and browser instance, connecting across 4,000 application plugins to handle continuous workflows in software engineering, data research, and enterprise operations. Designed to maintain cross-channel contextual memory, users can deploy and interact with their Dot across ChatGPT, Slack, and Microsoft Teams. The agent proactively updates users on project progress, flags required approvals, and automatically reruns data models when fresh inputs arrive.
Dots is the consumer-facing demonstration of the same direction, but it is not a replacement for a developer API. That distinction matters enormously if you are making a build-vs-buy call. OpenAI Dots just changed the end-user experience, but the developer surface is a separate stack. Understanding where OpenAI Dots just changed the boundaries between consumer and developer tooling is essential before committing to an architecture.
The New Developer Infrastructure: Agents API and Decisions API
Alongside Dots, OpenAI shipped two new API primitives that are the more consequential announcement for builders.
Agents API (Public Beta)
The Agents API now supports computer use, allowing agents to operate software through its interface, with OpenAI running the Codex harness. OpenAI also added support for multi-agent orchestration, tool search, and context compaction. In practical terms, applications can give an agent tools and a task, follow progress, and send more input to the same session. OpenAI handles more of the loop that otherwise lives in application code. Developers still choose the tools and the environment in which those tools operate.
The Agents API is now in public beta. That is a meaningful shift from the Codex harness being an internal OpenAI tool to something developers can directly integrate into products. OpenAI Dots just changed the scope of what “managed agent infrastructure” means for teams evaluating this beta.
Decisions API (Limited Preview)
The Decisions API is designed for situations where an application needs an AI model to select from a defined set of answers. OpenAI showed applications such as classification, routing, and deciding the next action for an agent. The API was announced in limited preview. OpenAI announced it at DevDay on September 29, 2026, and says it runs on GPT-6 Luna. It is built for jobs like ticket classification, routing, and picking an agent’s next step.
One caution worth flagging: the keynote supplied no exact Decisions API rate card. No docs, no price, and no benchmarks is a good enough reason not to build a roadmap on it this week. Monitor availability before committing it to a critical path.
The GPT-6.1 Sol Model: The Affordable API Engine for Agents
OpenAI Dots just changed what the “affordable tier” looks like for agentic workloads. The GPT-6.1 Sol post claims it “nearly matches GPT-6 Astra’s intelligence on agentic coding, computer use, and professional work at one-fifth of Astra’s standard input and output token prices.”
The API model costs $2 per million input tokens, $0.10 per million cached input tokens, and $10 per million output tokens at standard rates. OpenAI’s current API documentation lists a 1,050,000-token context window and 128,000 maximum output tokens. The model ID is gpt-6.1-sol. For comparison, GPT-6 Astra is priced at $10 input, $1.00 cached, and $50 output per million tokens.
This matters for the build decision: GPT-6.1 Sol is the engine you would use inside your own custom agent loop if you choose the API route over Dots. The cost difference between self-built (GPT-6.1 Sol at $2/$10) and Astra-based Dots is substantial at scale.
Build on Top of Dots, or Roll Your Own Agent?
This is the real strategic question, and OpenAI Dots just changed its parameters. Here is the framework.
When Building on the Dots/Managed Layer Makes Sense
OpenAI previewed enterprise-level “specialist” Dots, tailored agents designated for specific organizational roles — which are launching through guided pilots and will integrate with Microsoft Agent 365 for administrative security and compliance governance. If your target users are already on ChatGPT Pro or Business Premium, and your workflow fits inside the 4,000-app plugin ecosystem, the distribution advantage is real. OpenAI expanded its commitment to an open ecosystem by opening up ChatGPT as a shared surface where humans and agents can collaborate and where developers can directly launch new native experiences to its collective 1.2B weekly users.
For teams that need fast time-to-market on a standard workflow, for a minimal “hire me inside ChatGPT” prototype, you do not need a platform team on day one. A thin API plus a tool definition that maps to one boring workflow is enough to learn whether routing picks you. OpenAI Dots just changed how quickly a team can validate this kind of prototype against a real user base.
When Rolling Your Own Agent Is the Better Call
The API route gives you exact cost accounting and full control of the tool surface, which Dots does not. This matters if your agents must handle proprietary data under strict retention policies, run on non-OpenAI models, or require pricing predictability at scale.
With Dots, your conversations don’t count toward ChatGPT usage limits, but deeper work draws on a plan allowance whose post-launch terms OpenAI has not published. That opacity is a real budgeting risk for enterprise deployments. With Dots, the option to lock pricing doesn’t exist yet: Pro is monthly only, and the parts most likely to cost extra have no rate card.
Agents API + computer use is where you would not start unless the workflow truly requires clicking legacy UIs — otherwise prefer APIs and structured tools. If your automation involves clean API surfaces, building with GPT-6.1 Sol directly will be cheaper and more predictable than piggybacking on Dots’ cloud computer.
Availability and Geographic Constraints You Cannot Ignore
Dots are rolling out in ChatGPT to Pro and Business Premium users in all markets excluding the European Economic Area, Switzerland, and the UK. Enterprise users (including Edu and Healthcare) can try the beta when their workspace admin enables it. If a significant portion of your user base is in the EEA, building on Dots today means shipping a half-available product — another reason OpenAI Dots just changed the geographic planning calculus for internationally focused teams.
A Decision Framework for Developers
OpenAI Dots just changed the options, but not the underlying logic of the decision. Use this framework to orient your architecture.
Build on Dots or Managed Layer if: your users are on eligible ChatGPT plans, your workflow fits existing plugin integrations, fast distribution matters more than cost control, and you are building a B2C product where 1.2B ChatGPT users is an asset.
Roll your own with the Agents API + GPT-6.1 Sol if: you need exact cost accounting, operate under data residency or deletion requirements, need to swap models (including non-OpenAI ones), or are building infrastructure where the agent is a backend component, not a user-facing product.
Use the Decisions API for routing if: you currently chain two or three LLM calls just to classify or route a request. Think routing, not reasoning. The Decisions API is where you would replace brittle “if message contains X” logic in existing automations. But wait for pricing documentation before adding it to production pipelines.
Strategically: OpenAI will happily own Decision inside ChatGPT. Defensible products still tend to own two of Trigger, Action, and Feedback — the places your domain data and liabilities live. That is the real moat OpenAI Dots just changed the shape of: the decision layer is commoditizing, so your value moves to proprietary triggers and feedback loops.
What to Watch Before Finalizing Your Agent Architecture
Several critical details were not published at DevDay. The practical recommendation is to test Sol and the Agents API first, use Codex Cloud where remote execution saves coordination time, and treat Dots as a product signal rather than a stable integration surface.
Specifically: the Decisions API rate card is not public; OpenAI is partnering with Amazon to host Dots on AWS, but terms for Bedrock Managed Agents are still rolling out; and the EEA availability gap for Dots has no confirmed timeline. Also relevant for security-conscious teams: our article on NVIDIA’s AI Agent Safety Platform covers the compliance layer you will need regardless of which infrastructure choice you make, and if you are evaluating the underlying model for your own agent loop, the breakdown in GPT-6 Sol vs GPT-6 Luna vs Claude Opus 5.5 for agentic workflows is directly relevant.
OpenAI Dots just changed the infrastructure defaults developers work against. That does not mean switching wholesale. It means re-auditing your agent architecture against a new baseline: persistent cloud computers with 4,000 integrations at no marginal cost on Pro plans, a managed Agents API in public beta, and GPT-6.1 Sol at $2/$10 per million tokens as the capable mid-tier engine. Decide where OpenAI’s managed layer saves you engineering time, and where your domain specificity demands you own the stack. That line is different for every product — but now you have real numbers to draw it with.