AutomaterOpenAI's Agentic Stack: From Research Papers to Dev Day to What You Can Build
Every OpenAI Dev Day decoded, 2023–2026: the agent primitives that survived, what the Assistants API sunset teaches, and what to build on without whiplash.
Go deeper. Build your own.
The agent story hiding in OpenAI’s release notes
OpenAI does not publish roadmaps. It publishes ship dates — and, once a year, a keynote. OpenAI Dev Day, the company’s annual developer conference, is the closest thing to a strategy document it offers, and the deprecation-page edits that follow each edition tell you more than the demos do. If you ship on the OpenAI API or run Codex daily, learning to read that record is not optional homework. It is how you avoid building your product on the next Assistants API.
This piece is written for a specific reader: a builder deciding which OpenAI primitives deserve an abstraction budget, probably burned at least once by a rename or a deprecation. The claim is that OpenAI’s output has a legible throughline — research artifact to model capability to API primitive to product — and that reading it correctly tells you what is safe to build on before OpenAI says so out loud.
What follows is the agent-builder’s decode, not a company profile. It pairs deliberately with our Anthropic analysis: two companies, two theories of the agent platform, best read together. And for the wider shift from generative AI programming to agentic systems, the agentic software pillar holds the foundations this article assumes.
OpenAI Dev Day, the event: cadence, format, and how to follow it
For readers who arrived wanting event facts, here they are, compressed.
| Edition | Date | Location | Agent-relevant headliners |
|---|---|---|---|
| Dev Day 2023 | November 6, 2023 | San Francisco | GPT-4 Turbo (128K context), GPTs, Assistants API |
| Dev Day 2024 | October 1, 2024 | San Francisco, plus London (Oct 30) and Singapore (Nov 21) satellites | Realtime API, prompt caching, model distillation |
| Dev Day 2025 | October 6, 2025 | San Francisco | AgentKit, Apps SDK, Codex GA |
| Dev Day 2026 | Fall, by pattern; unannounced as of late August 2026 | — | — |
As AI developer conferences go, the format is classic: an opening keynote carrying the strategy, then breakout sessions where the GA-versus-preview truth leaks out. Keynotes are streamed and archived on OpenAI’s YouTube channel, with the written record landing on the openai.com announcement index. The audience is API developers — this is a different animal from research drops and consumer launch livestreams, which run on their own calendar.
The viewing guide that saves you hours: watch the keynote for direction, skim the breakouts for maturity signals, then watch the API documentation — pricing tables and the deprecations page — for the two weeks after. The keynote tells you what OpenAI wants to be true. The docs tell you what is.
Attendance itself is a lottery — the in-person edition runs a few thousand seats and skews toward invited API customers — but nothing strategic requires being in the room. The announcements post the same morning, the sessions archive within days, and the deprecation-page diffs, the part that actually matters, are public to everyone.
From papers to primitives: how OpenAI actually ships
The reliable pattern across five years of output: research artifact → model capability → API primitive → product. Computer use ran the whole pipe in public view. The Computer-Using Agent work surfaced as Operator in January 2025, a ChatGPT Pro research preview; the same capability appeared as a computer-use tool in the API that March; and by mid-2025 the consumer surface had been folded into ChatGPT’s agent mode . Research, model, primitive, product — about six months, end to end.
If you search “openai paper” expecting methods papers, recalibrate. The GPT-4 technical report (2023) famously declined to describe the architecture, and that was the pivot point: disclosure now lives in system cards, the Model Spec, the preparedness framework, and safety evaluations rather than in reproducible research. The documents that repay close reading are the flagship system cards (tool-use behavior, injection resistance), the Model Spec (what the model is supposed to do, in writing), and the deprecations page — which is the real roadmap.
The direction of a launch is a tell worth learning. ChatGPT-first launches signal consumer experiments: Operator (January 2025), deep research (February 2025, reaching the API mid-year), the Atlas browser (October 2025, still without an API surface ). API-first launches signal infrastructure bets that expect developers to build the products: function calling (June 2023), structured outputs (August 2024), prompt caching (October 2024).
Two of those examples show why the tell works. Structured outputs shipped API-first because its only customers are programs — no consumer notices guaranteed JSON. Deep research shipped ChatGPT-first because it demoed well and needed months of usage data before an API contract was worth freezing. When a capability you want appears, ask which side of the pipe it entered from, and whether it has crossed yet. Uncrossed capabilities are previews wearing product names.
The builder rule falls out of the pattern: primitives that complete the full pipeline get durable support, because OpenAI’s own products come to depend on them. Features that stall mid-pipeline are deprecation candidates. ChatGPT plugins stalled and died within a year. The Assistants API stalled in beta — the autopsy comes below.
Three lanes, four years: the agent-relevant record from function calling to GPT-5.6 (Sol).
The agent-relevant timeline
Selection rule: only changes that mattered to agent builders make this list; consumer launches without agent relevance are omitted on purpose. The arc in one line: 2023 shipped the primitive, 2024 bought plan quality, 2025 consolidated the stack, and 2026 so far is model cadence rather than stack rebuilds.
2023: function calling and the first Dev Day
- March 2023 — ChatGPT plugins. The false start: tool use packaged as a consumer feature. Deprecated within a year, but it taught OpenAI where tool use actually belonged — in the API.
- June 2023 — function calling. The true start of the agent era. Structured JSON tool invocation turned a chat model into an actuator, and every agent stack since, from every vendor, builds on that shape.
- November 6, 2023 — Dev Day 2023. GPT-4 Turbo with 128K context, GPTs, and the Assistants API: OpenAI’s first agent-framework bet, with threads and runs managed server-side.
- In hindsight, the Assistants design guessed that developers wanted OpenAI to own their conversation state. Hold that thought for the deprecation section.
2024: reasoning models and the quiet Dev Day
- September 12, 2024 — o1-preview. Reasoning became a purchasable product line. Plan quality turned into a pricing tier, which changed what agent planners could responsibly attempt.
- October 1, 2024 — Dev Day 2024. No frontier model. Instead: the Realtime API, prompt caching, model distillation, and vision fine-tuning — exactly the primitives agents needed (voice loops, cheap context re-sends) and nothing built for a hype cycle.
- October 2024 — Swarm. An “experimental, educational” multi-agent orchestration repo that was obviously more than that. It became the Agents SDK five months later.
- Computer-use groundwork from this period surfaced as Operator in January 2025 — the bridge to everything that followed.
2025: the agentic consolidation
- March 11, 2025 — Responses API and Agents SDK, launched together. A new core primitive with hosted tools (web search, file search, computer use) plus an open-source orchestration layer — and the Assistants API marked as superseded the same day. OpenAI’s strategy became legible in one announcement.
- March–May 2025 — MCP. Model Context Protocol support landed in the Agents SDK, then remote MCP servers became a Responses API tool. Adopting a protocol authored by Anthropic was the year’s clearest concession to how builders actually behave.
- April–October 2025 — Codex’s return. Codex CLI in April, Codex cloud in May, an IDE extension and dedicated coding models by September, GA at Dev Day.
- August 7, 2025 — GPT-5, priced aggressively under the coding-agent competition.
- October 6, 2025 — Dev Day 2025. AgentKit (Agent Builder, ChatKit, expanded Evals, Connector Registry), the Apps SDK building ChatGPT apps on MCP, and Codex general availability. Agents were the keynote, not a track.
2026: the Sol era
- A fast model cadence through the first half. GPT-5.3, 5.4, and 5.5 per reporting , culminating in GPT-5.6 (Sol), the flagship as of August 2026.
- Codex, current form. CLI, cloud, and IDE surfaces riding the GPT-5.6-era coding models — the daily-driver details live in our Codex deep dive.
- The Assistants endgame. Per the plan stated in March 2025: formal deprecation in the first half of 2026, with roughly a year of support to follow .
- Security candor. OpenAI’s head of preparedness said prompt injection against browser agents like Atlas “may never be solved” — the frankest sentence any lab shipped this year, and a real constraint on what you delegate to computer-using agents.
The current stack map: which primitive for which job
Names below are current as of August 2026. OpenAI renames aggressively, so treat this table as dated the day it was printed.
| Primitive | The job it’s for | Maturity (Aug 2026) | Watch-outs |
|---|---|---|---|
| Responses API | Core model calls; hosted tools: web search, file search, computer use, remote MCP | GA — the stated long-term core | New capabilities land here first; Chat Completions is maintained but second in line |
| Agents SDK | Multi-agent orchestration: handoffs, guardrails, sessions, tracing | GA, open source | It is a framework — wrap it behind your own interface |
| AgentKit: Agent Builder, ChatKit, Connector Registry | Visual agent assembly, embeddable chat UIs, connector governance | Mixed — ChatKit and Evals arrived GA; builder pieces matured unevenly | Young; public adoption data still thin |
| Realtime API | Voice agents and speech-to-speech loops | GA since August 2025 | Session cost and complexity — model the economics first |
| Computer use | GUI automation where no API exists | API tool; consumer surface lives in ChatGPT agent mode | Modest success rates on long GUI tasks; prompt-injection exposure |
| Codex | Agentic coding: terminal, cloud delegation, IDE, Slack | GA | Plan limits and model routing; see the deep dive |
| Evals | Regression safety for prompts, tools, and agents | GA | Tooling is not a strategy — bring an eval discipline |
Note what is conspicuously absent: durable cross-session memory you control, anything cross-provider, deep searchable session history. The Connector Registry gestures at enterprise tool governance, but it governs OpenAI’s connectors, not your fleet’s . Those gaps are why the agent framework ecosystem exists and why third-party layers keep appearing above every vendor’s stack. OpenAI sells the parts of the loop; it does not yet sell you the memory of having run it.
Codex’s second act
The arc, told straight: the 2021 Codex model powered the original GitHub Copilot; OpenAI shut it down in March 2023; and the name returned in 2025 attached to the agentic coding push — Codex CLI in April, Codex cloud in May, then IDE, Slack, and SDK surfaces at GA. Three unrelated products, one brand, four years. Rename-resistance is a core competency for OpenAI watchers, and Codex is the training set.
The 2026 form is a stack, not a tool: terminal, cloud delegation, IDE, Slack, and an embedding SDK, sold through ChatGPT plans with usage-based overflow . Strategically it is OpenAI’s most complete pipeline product — research to model to primitive to revenue in one line — which is precisely why it gets the naming care and the keynote minutes.
The strategic read is more interesting than the naming. Coding agents are the proven agent revenue category, and OpenAI competing head-on validates a category it initially ceded: Claude Code normalized the terminal agent in 2025, Codex made it a two-vendor race, and Google’s entry completed the field until Gemini CLI was discontinued in June 2026 in favor of Antigravity CLI. Where Codex fits in a multi-CLI setup, per field reports rather than tribal loyalty:
- Codex strengths: cloud delegation — fire-and-forget tasks in sandboxed containers — tight GitHub integration, and plan pricing bundled with ChatGPT tiers .
- Claude Code strengths: the deeper harness surface (hooks, subagents, skills) and the coding-agent mindshare it earned first.
- The modal power user runs both, routes by task, and keeps one command center over the whole fleet rather than betting the workflow on either vendor.
The deprecation lesson: the Assistants API arc
Announced at Dev Day 2023 as the agent framework. Beta from day one. Never GA. Superseded by the Responses API in March 2025, with formal deprecation following on the stated schedule — first half of 2026, then a migration window . For something pitched as the foundation of agentic apps, that is a fast arc.
Why it lost is worth stating precisely, because the diagnosis transfers. Assistants managed threads and runs server-side: OpenAI held your conversation state, your tool configuration, your execution loop. The design guessed that developers wanted an agent backend. What developers wanted was lower-level primitives plus ownership of their own loop — state they could inspect, migrate, and replay. The Responses API is the corrected guess, and its adoption curve was the proof.
For teams that bet on Assistants, the cost was concrete: exporting thread state, re-wiring tools, and re-running behavioral evals against a different execution model. Weeks per serious production integration, not days — and the eval re-run is the part teams skip at their peril.
The mechanics generalize to any framework sunset, so itemize them once. Exported thread histories arrive as data, not behavior — conversation state has to be reshaped into whatever store your new loop reads. Tool definitions port syntactically but register differently. And every implicit behavior of the old runtime — truncation rules, retry semantics, tool-choice defaults — becomes an explicit decision you now own. None of it is hard. All of it is work that ships no visible feature.
The generalization needs care, because the record is genuinely two-sided. OpenAI’s model APIs have been notably stable — Chat Completions code from 2023 still runs today. The framework layer is where consolidation strikes. That two-layer split is the operating rule of the next section.
Building on OpenAI without strategy whiplash
- Own the loop. Keep the agent loop, state, and prompts in your own code. Treat vendor SDKs as adapters behind one interface you could re-point in a day — history says that day arrives roughly annually.
- Write tools as MCP servers. Model Context Protocol support spans the Agents SDK and the Responses API , and the protocol itself went stateless in the 2026-07-28 revision. A tool server written once survives vendor churn — the highest-leverage hedge available. Primer at MCP explained.
- Practice deprecation hygiene. Check the deprecations page monthly, pin model versions, budget quarterly migration time, and keep a second provider warm enough to fail over. If that second provider is Anthropic, the API and Console guide is the fifteen-minute setup.
- Apply the two-layer rule. Models are swappable: bet freely — GPT-5.6 (Sol), the Codex coding models, the realtime models. Frameworks are sticky: bet cautiously — Agents SDK, AgentKit, Apps SDK. The Responses API sits between: thin enough to wrap, central enough that OpenAI cannot afford to break it.
OpenAI vs Anthropic: two theories of the agent platform
OpenAI is product-led. Consumer gravity at ChatGPT scale — 800 million weekly users was the figure claimed at Dev Day 2025 — funds the frontier, and primitives tend to ship once a product has proven them. Anthropic is protocol-and-primitives-led: an enterprise-heavy API mix , MCP given away to win the ecosystem, Claude Code as the harness that taught the market. The full case study is the companion Anthropic piece; the 2026 flagships arrived months apart — Claude Fable 5 and Mythos 5 in June, GPT-5.6 (Sol) at the top of OpenAI’s 5.x cadence.
| Dimension | OpenAI | Anthropic |
|---|---|---|
| Center of gravity | Consumer products fund the platform | Enterprise API funds the platform |
| Agent surfaces | Codex CLI / Codex cloud, AgentKit, Apps SDK | Claude Code, Agent SDK, MCP stewardship |
| Protocol posture | Adopted MCP (2025) | Authored MCP (2024) |
| Flagship, Aug 2026 | GPT-5.6 (Sol) | Claude Fable 5 |
| Honest strengths | Distribution, realtime and voice maturity, pricing aggression | Coding-agent mindshare, protocol credibility, harness depth |
The convergence is the real story. Both ship agentic CLIs, both support MCP, both sell agent SDKs and eval tooling — and by mid-2026, essentially every serious harness speaks one or both of their wire formats. Differentiation is narrowing to models, pricing, and trust. The posture most power users already hold is the correct one: both, routed by task. The interesting question is portfolio allocation, not allegiance.
Product note: If you run Codex and Claude Code side by side — most readers here do — Automater Lite is the neutral layer above both: one local archive, full-text search, and per-provider token metering across every CLI’s sessions. Free on automater.ai.
Reading OpenAI like an analyst: the Dev Day scorecard
Rank the primary sources before you read anything else: system cards and the Model Spec first (behavioral commitments), then the deprecations page (the real roadmap), then pricing-page diffs (competitive posture), then keynote claims. Blog posts are announcements, not commitments — the distinction pays rent. One illustration: the Realtime API’s GA pricing in August 2025 came in below the preview numbers most teams had budgeted from launch coverage. The docs won, in your favor that time; the direction of the correction is not guaranteed.
Then build the pattern library. Renames signal consolidation: Assistants became Responses; Swarm became the Agents SDK. Price cuts signal competitive pressure: GPT-4 Turbo undercut its own predecessor in November 2023, and GPT-5’s August 2025 launch pricing landed under the coding-agent incumbents . ChatGPT-first launches signal consumer priority — and, historically, a three-to-six-month API lag.
The scorecard that keeps keynotes honest — announced versus GA within twelve months:
| Dev Day announcement | GA within 12 months? |
|---|---|
| GPT-4 Turbo (2023) | Yes |
| GPTs (2023) | Yes — Store followed in January 2024 |
| Assistants API (2023) | No — never left beta |
| Realtime API (2024) | Yes — GA August 2025, month eleven |
| Prompt caching (2024) | Yes — live at announcement |
| Model distillation (2024) | Shipped, quietly |
| Codex GA (2025) | GA at announcement |
| AgentKit (2025) | Partial — components staggered |
| Apps SDK (2025) | Preview at announcement |
The batting average: strong on models and infrastructure, mixed on frameworks and app-store-shaped promises. Weight your bets accordingly.
What to build on today, what to wait out
Build on now
- The Responses API with function calling and MCP tools — the stable center of the stack, on the record.
- Evals from day one — the tooling is GA, and the discipline transfers to every provider you will ever use.
- Agentic coding for your own development — Codex and its peers are the proven category; you should be a daily driver before you are an architect.
Adopt with hedges
- The Agents SDK — genuinely useful orchestration, but wrap it: frameworks are where the churn lives.
- Realtime for voice agents — GA and maturing; model the session economics before you commit a product to it.
Wait and watch
- Agent Builder’s visual promise and Apps SDK distribution, until public adoption data exists .
- Anything announced but not GA. The scorecard above is the base rate.
Assume multi-provider from day one. It forces better abstractions, honest evals, and real cost visibility — benefits you collect even if you never switch.
The whole article, compressed to a posture: read the pipeline, not the keynote; bet on the layers with a track record of stability; and keep every vendor, OpenAI included, behind an interface you own. Do that, and the next Dev Day is information rather than risk.
FAQ: OpenAI Dev Day and the agentic stack
When is the next OpenAI Dev Day?
OpenAI runs Dev Day annually, typically in the fall in San Francisco: November 2023, October 2024, October 2025, with satellite editions in London and Singapore in 2024. As of late August 2026 the next edition had not been formally announced ; the pattern points to fall. Watch openai.com.
What was announced at OpenAI Dev Day 2025?
The October 6, 2025 edition headlined AgentKit — Agent Builder, ChatKit, expanded evals, and a Connector Registry — plus the Apps SDK for building ChatGPT apps on MCP, Codex reaching general availability, and API additions including gpt-5-pro and Sora 2. Agents were the keynote, not a side track.
What is the OpenAI Agents SDK?
The OpenAI Agents SDK is an open-source orchestration library for multi-agent systems: handoffs between agents, guardrails, sessions, and tracing, with MCP tool support built in. It replaced the experimental Swarm project in March 2025, and it can drive non-OpenAI models through compatible APIs.
Is the Assistants API deprecated?
Yes. OpenAI superseded it with the Responses API in March 2025 and set formal deprecation for the first half of 2026, with roughly a year of support after . Prompts and tools port cleanly; server-side thread state is the part that needs re-architecture.
Does OpenAI support MCP?
Yes, since 2025. The Agents SDK supports MCP servers, the Responses API calls remote MCP servers as hosted tools, and the Apps SDK is built on the protocol. It matters because MCP tools survive vendor churn: write a server once, point it at any compliant stack.
Which OpenAI papers should I read for agents?
OpenAI’s substantive disclosure now lives in system cards and specs rather than methods papers. For agent work, read the current flagship’s system card (tool use, injection resistance), the Model Spec (intended behavior), the preparedness framework, and the computer-use and reasoning documentation on the API docs site.
