OpenAI DevDay 2026 made one shift fairly clear in how the company is building its developer platform: the model still matters, but the model is no longer the whole story. GPT-6.1 Sol cuts the cost of heavy workloads; the Agents API adds computer use and multi-agent support; Codex moves deeper into the cloud; the Decisions API targets small but repeated decisions; and plugins can become interactive experiences right inside ChatGPT.

In short: OpenAI is moving from “calling a model through an API” to “building agents that can see, decide, use tools and get work done”.

GPT-6.1 Sol: closer to Astra, but noticeably cheaper

One of the most important announcements is GPT-6.1 Sol — an upgrade of GPT-6 Sol, focused on three workload groups: coding, computer use and professional work.

According to OpenAI, GPT-6.1 Sol gets close to GPT-6 Astra across many evaluations of agentic coding, computer use and professional work, while its standard token price is about one-fifth of Astra. Specifically, Sol is listed at roughly $2 per million input tokens and $10 per million output tokens, with cached input at $0.10 per million; it has a context window of about 1.05 million tokens and can output up to 128,000 tokens.

For developers this may be a more practical change than a new benchmark. A long-running agent usually doesn’t call the model just once — it reads context, calls a tool, inspects the result, reasons, calls again, checks, fixes, and continues. The more expensive the model, the harder it is to scale this kind of workflow.

GPT-6.1 Sol targets exactly that problem: keep capability high while cutting cost so an agent can take more steps.

The Agents API can now use a computer

This is perhaps the most notable announcement if you’re building agents. The Agents API now supports computer use, letting an agent operate software through its graphical interface.

Instead of every integration needing its own API (agent → API → application), some workflows can become: agent → computer use → interface → click/type/navigate → application. This is especially useful for:

  • legacy software
  • internal dashboards
  • websites without a suitable API
  • workflows that span multiple applications

Computer use doesn’t make traditional APIs unnecessary: for actions with a stable API, the API is still usually easier to control and more efficient. What’s new is that developers have another path for the parts that used to be very hard to automate.

The Agents API is no longer just a wrapper around a model

Computer use is only one part. According to the post-DevDay roundups, the Agents API (public beta) also includes hosted execution, memory, tools, tool search/calling, context compaction and multi-agent support.

This changes the abstraction. Developers used to build the LLM, memory, a tool router, an execution loop, context management and agent orchestration themselves. OpenAI is now moving many of those layers into the platform — an agent is given memory, tools, computer use and hosted execution out of the box. Developers still decide what the agent does, but have to manage less plumbing.

Codex moves from the local machine to the cloud

Codex was also a big part of this year’s DevDay. Codex can run in a cloud environment instead of always requiring the developer’s local machine to handle a task — letting you start tasks from another device and let the work keep running remotely.

The CLI also gains capabilities like voice input and an /agents interface to assign and track multiple tasks.

This is a fairly big shift in how we see a coding agent. It used to feel like “a pair programmer sitting next to you”; cloud execution moves it closer to “hand off a task → the agent does it → come back to check the result”.

Code review and security also enter the agent workflow

Codex doesn’t just write code. DevDay introduced review workflows that can analyze GitHub pull requests, GitLab merge requests, diffs and potential issues. Codex Security Cloud can also scan the repository and new commits, investigate findings, remove duplicates and prepare fixes.

What’s notable isn’t just “AI reviews code”. The broader direction is a chain: requirement → agent writes → agent tests → agent reviews → security scan → human approves. The coding agent is expanding across more stages of the software lifecycle.

Decisions API: not everything needs a large model

A less flashy but interesting announcement is the Decisions API, now in limited preview. It uses the smaller Luna model to pick one answer from a developer-defined set of options, based on text or image context. OpenAI says it responds very fast — about 150 ms per request versus 1.6 s on the Responses API (roughly 10x faster).

Some typical use cases:

  • classification
  • request routing
  • choosing the next agent
  • deciding the next action

For example: an incoming request can be classified straight into Billing / Support / Technical; or from an agent’s state, the next step can be chosen among Search / Ask / Execute / Escalate. It’s a notable design because not every decision in an agent system needs the strongest model — if a step only needs to pick A/B/C/D, a smaller, faster and cheaper model can make more sense.

ChatGPT plugins are becoming a UI platform

DevDay also expanded ChatGPT’s plugin system. Developers can build sidebar experiences, interactive conversation panels and custom file viewers. Plugins can also react to events through the proposed MCP Events, letting automation start when something happens in a connected app.

This opens a different direction from the traditional chatbot. No longer just user → prompt → text response — ChatGPT can hold conversation, interactive UI, files, external apps and events. Developers can build part of the product experience right inside ChatGPT, instead of always sending users off to another website.

Dots: agents that no longer wait for you to ask

One of the standout products of DevDay is Dots. OpenAI describes Dots as always-on agents (built on the GPT-6 Astra model) that can keep working on the user’s behalf and gradually learn what matters to them — each Dot has a cloud computer and browser, can write and test code, and uses connected apps.

This isn’t just a consumer feature separate from the developer story — it clearly reflects the direction the whole DevDay is heading. Chatbot: you ask → the AI answers. Agent: you hand off work → the AI does it. Persistent agent: the AI holds context → keeps working → watches for changes → acts when needed. DevDay 2026 is largely about building the infrastructure for that third shift.

ChatGPT Space brings people and agents into one workspace

Another announcement is ChatGPT Space, introduced as a shared workspace where a team and agents can work with shared context. Pairing Space with Dots, plugins and the agent infrastructure, the bigger picture emerges: people, agents, data and apps coexist in one workflow — rather than just standalone chatbots.

What actually changes for developers?

If you strip away the product names, DevDay 2026 can be summed up as four shifts:

  • Model → Agent: the model still matters, but the API layer increasingly handles memory + tools + computer + execution.
  • Local → Cloud: Codex can keep working in the cloud instead of depending entirely on the developer’s machine.
  • Prompt → Workflow: developers don’t just write prompts — they design state → decision → tool → action → verification.
  • Reactive → Persistent: Dots and event-driven plugins point toward agents that keep working after the initial chat ends.

This is a bigger architectural change than simply having a higher model benchmark.

If you’re building an AI product, what to care about first?

Not every developer needs every announcement:

  • Building a coding workflow: GPT-6.1 Sol + Codex Cloud + code review.
  • Building business automation: Agents API + computer use + Decisions API.
  • Building a product inside ChatGPT: plugins + interactive UI + events.
  • Building a long-running agent: hosted execution + memory + context compaction + multi-agent.

And if you’re only calling a model to summarize, classify or generate text, you don’t necessarily need to move your whole architecture to agents right away. DevDay adds options; it doesn’t instantly make every app need an autonomous agent.

Agent cost is starting to be treated as an architecture problem

GPT-6.1 Sol is a clear example: OpenAI stresses that the model reaches capability close to Astra on some workloads while its standard token price is only about one-fifth. This matters because agents differ from chatbots in how many times the model is called.

A chatbot request might be 1–2 model calls; an agent task might need 20, 50 or more than 100 model/tool interactions. So “cost per token × number of steps × number of agents” quickly becomes part of system design.

Smaller models like Luna (for the Decisions API) and stronger models like Sol (for execution) reveal a pattern: cheap models to route/classify/decide, strong models to reason/code/execute, and tools for the deterministic work. Not every step needs a frontier model — perhaps one of the most practical lessons of this year’s DevDay.

Frequently asked questions

  • When did DevDay 2026 take place? — On 29 September 2026 at Fort Mason, San Francisco.
  • What’s the notable new model? — GPT-6.1 Sol, focused on coding, computer use and professional work; OpenAI says its standard token price is about one-fifth of Astra (around $2 input and $10 output per million tokens).
  • What’s new in the Agents API? — Hosted execution, memory, tools, multi-agent and especially computer use (public beta).
  • What’s new in Codex? — Cloud environments, multi-agent workflows, voice input, plus code review and security workflows.
  • What is the Decisions API? — A limited-preview API that uses the Luna model to pick from predefined actions/answers, suited to classification and routing (about 150 ms per request, ~10x faster than the Responses API).
  • What is Dots? — Always-on agents (built on GPT-6 Astra) that can keep working on the user’s behalf.
  • What’s new with plugins? — Interactive panels, sidebar experiences, file viewers and event-driven workflows (MCP Events).

DevDay 2026’s message to developers

This year DevDay didn’t just ask “how much smarter is the new model?” but a bigger question: “if the model is smart enough, what infrastructure do we need for it to actually get work done?”.

GPT-6.1 Sol solves part of the capability-and-cost problem; the Agents API solves execution; computer use expands the range of software an agent can operate; the Decisions API handles the smaller decisions; Codex Cloud takes the coding agent off the local machine; plugins connect ChatGPT to apps; Dots moves agents from reactive to persistent.

Overall, DevDay 2026 shows OpenAI trying to turn AI development from “model + prompt” into “model + memory + tools + computer + workflow + execution + UI”. For developers, this may be a more meaningful change than any single benchmark.