OpenAI DevDay 2026 preview: what ships on September 29? GPT-6 Astra, Agents API, Hosted Sandbox, Codex, API pricing, and AI agent features

OpenAI DevDay 2026 is days away. The site pins the date to Tuesday, September 29, 2026, at Fort Mason in San Francisco. The keynote starts around 10:00 a.m. with Sam Altman and is free to stream; breakout recordings land on openai.com afterward. In-person registration is closed. Tickets were listed at $650, so for most people the livestream and the docs matter more than a seat in the hall.

A more useful question than “will they drop another model name on the 29th” is: is what already landed in early September enough to change your routing, your bill, and your execution environment now? Astra, Agents API, Hosted Sandbox, and the Codex harness are in the docs—not a preview slide. This piece follows the DevDay site, the Astra announcement, the Agents API announcement, and the pricing page. Prices and entry points are as of documents visible on September 20, 2026. If anything moves on the 29th, trust the in-product console.

What DevDay on September 29 actually is

This is OpenAI’s annual conference for people who write code, not a consumer launch show. The site names engineers, technical founders, researchers, and technical leads who are already (or about to be) building products with AI. The public agenda:

OpenAI also said DevDay Exchanges will expand globally, but the 29th still has one main stage in San Francisco. Register for livestream reminders at devday.openai.com—you do not need an in-person ticket.

Same as every year: the keynote owns the narrative. The numbers you can put in config live on developers.openai.com in the model page, the pricing page, and the Agents guide. For the first 24 hours after the show, check the docs before you buy from a social screenshot.

The four-piece stack already live—do not wait for the keynote

In early September 2026, OpenAI already handed developers the next-generation agent stack in four pieces. The 29th looks more like folding them into one product line than launching from zero.

We already covered Astra’s features, ChatGPT entry points, and upgrade rules in GPT-6 Astra features, pricing, and how to use it. This piece is the DevDay view: how those blocks become a billable agent development stack, and which knobs the 29th is most likely to turn.

GPT-6 Astra: flagship model, entry points, and price

GPT-6 Astra is OpenAI’s strongest public text flagship, aimed at “the hardest end-to-end work”: complex reasoning, software engineering, Computer Use, research, and long documents. Input is text plus images; output is text. The official one-liner is “our strongest model, built for the hardest end-to-end work”—developers should remember the model ID and the bill, not the slogan.

• API ID: gpt-6-astra. It will also ship on Microsoft Azure and AWS Bedrock. Do not hard-code those marketplace IDs in production routing until the listings exist.
• Context: about 1.05 million tokens, output cap about 128,000; knowledge cutoff 2026-04-30. Input over 272K bills the whole request at long-context rates (2× input, 1.5× output).
• Standard price: $10 input / $1 cached input / $12.50 cache write / $50 output per million tokens. Fast is about 2× speed and 2× price; Batch / Flex is half price.
• ChatGPT: Plus uses Work and Codex; the regular Chat picker is not the main entry. GPT-6 Pro in standard Chat is for Pro / Business / Enterprise. Enterprise is off by default and needs an admin to enable it.

OpenAI’s self-reported scores: Computer Use about 72.6% on OSWorld 2.0 and about 59.3% on Agents' Last Exam; stacked with the updated Codex harness, Mind2Web task completion is about 1.9× GPT-5.6 Sol. Treat that as a direction signal, not a contract acceptance clause. Same rule as the 2026 AI coding tools ranking: a benchmark says “it can chew a harder repo,” not “your monorepo merges overnight.”

Keep the daily loop on GPT-5.6 Sol (promo pricing at least through November 21: $4 / $20). Step up to Astra for hard cases, long-running agents, and Computer Use. Do not flip the default route just because “DevDay will talk about Astra.”

Agents API: the Codex harness as an interface

On September 10, 2026, OpenAI handed every developer the orchestration that already drives Codex and ChatGPT for Work, as an Agents API public beta. The official line: a useful agent needs a harness to manage context, use tools efficiently, and coordinate sub-agents—plus infrastructure that can run for days, read and write files, and keep intermediate results.

You pick the job, the model, the tools, and the environment; OpenAI hosts and maintains the harness. Compute can land on OpenAI’s hosted sandbox, your own machines, or partners such as Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel. The interface itself has no extra fee—you pay tokens and tools. That is not the same as wrapping another agent platform and charging a platform tax.

Customer numbers that keep showing up: Ciridae evals from 0.71 to 0.85, with sub-agents cutting latency about 4×; SafetyKit about 60% lower cost per case; Hypha about 86% fewer failed responses after splitting the harness from the sandbox. Those are early-adopter self-reports. They explain why teams are buying orchestration, not another chat wrapper.

The shape of one call

The session entry point is POST /v1/agents/sessions, with OpenAI-Beta: agents=v1 on the request. The SDK shape is client.beta.agents.sessions.create. Keys need api.agents.read, api.agents.write, and api.responses.write for inference. Keep the key on the application side; do not write it into sandbox environment variables—reserved names such as OPENAI_API_KEY, PATH, and CODEX_* are rejected.

curl --no-buffer --fail-with-body https://api.openai.com/v1/agents/sessions \
  -H "OpenAI-Beta: agents=v1" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent": {
      "model": "gpt-6-astra",
      "instructions": "Write clean code, run it, and report the actual output."
    },
    "environment": { "type": "openai_hosted" },
    "input": "Create tree.py, print a readable tree of the current directory, run it, show the output.",
    "stream": true
  }'

Public-beta docs are explicit: the Agents API does not support Zero Data Retention. Choosing self_hosted does not magically become ZDR either. For compliance work, read Data controls before a session leaves your network.

Sub-agents, tool search, and long sessions

The Agents API pulls three things you used to build yourself into the hosted layer:

• Long-session compaction: it automatically compacts as you near the context cap and keeps what you need to keep working. Multi-window workflows no longer need homemade summary logic.
• Tool search + programmable calls: load tool definitions on demand to cut tokens; programmable tool calls can run in parallel, chain, and filter results in code so only the relevant slice returns to context. MCP, custom functions, and built-in Web search are supported.
• Multi-agent: multi_agent.enabled + max_concurrent_subagents. Each sub-agent holds its own context; the main agent merges. That fits parallel research, analysis, and coding without a homemade orchestrator.

The harness is open source, and the hosted version ships with the model. When the model gains a capability, you often bump the model ID instead of rewriting orchestration. That is the engineering story worth hearing at DevDay: competition moved from “whose prompt chain is longer” to “whose harness keeps up with the model.”

Hosted Sandbox: how to use openai_hosted

The OpenAI hosted sandbox gives you a Linux workspace with Python, Node.js, and CLI tools ready. OpenAI provisions and connects it; you send the job and take the result. The working directory is /workspace. You can attach files, packages, skills, and plugins, and set string environment variables with env—but you cannot override reserved runtime names.

Network access is tightened by default. Docs often show network.access: "disabled"—get the script running in a disconnected sandbox first, then open the network if you need it. When you need your own image, CPU / GPU / memory sizes, a VPC, or private key storage, switch to self_hosted or a partner environment. Do not force the hosted sandbox to pretend it is those things.

Containers follow Hosted Shell / Code Interpreter standard pricing: 1 / 4 / 16 / 64 GB at about $0.03 / $0.12 / $0.48 / $1.92 per 20 minutes, per container. Eligible sessions can bill per minute, with a 5-minute minimum per session. Model tokens are extra. An agent idling for an hour can cost more in containers than a “free sandbox” story suggests.

Codex: cross-window notes and Computer Use

When Astra launched, OpenAI also updated the Codex harness. Long sessions used to compact work into one summary, and the reasons a fix failed—or how a component behaved—often disappeared. Astra can keep notes across multiple context windows, so older windows stay searchable for requirements and test results. The experiment lives in Codex config.toml; OpenAI said it would become the Astra default in the following weeks.

That is the Codex sentence to listen for on the 29th: whether notes are on by default, the minimum CLI version, and whether Desktop stays in sync. An old CLI will hide Astra entirely—the last wave already needed 0.153.0 before the model showed up.

Computer Use stacked with Hosted shell and Apply patch can edit files, run commands, and look at the screen in one session. For iOS / macOS developers, a Linux hosted sandbox can handle scripts and front-end work; the real toolchain still needs a Mac that stays awake. The model thinks in the cloud; xcodebuild has to accept on macOS.

API pricing: Astra, Sol, and containers

These are the USD per million tokens numbers on the pricing page as of writing. Tool calls (search, Computer Use, and the rest) are extra. The Agents API does not add a third “platform fee.”

Rough math: 1M input + 100K output is about $6 on the Sol promo, about $15 on standard Astra, and about $30 on Fast Astra. Then multiply by agent rounds and containers. For a fuller “API vs cloud host vs local” frame, see 2026 AI Agent compute costs and the LLM pricing and performance guide.

Five things to watch on the 29th

OpenAI has not published a full DevDay product list. These are knobs already named in the docs and most likely to be tightened or scaled that day—not leaks.

1. Agents API public beta → GA? Watch SLA language, ZDR / data residency, rate limits, and a GA date. Anything you write into a contract today is still beta.
2. Whether Codex cross-window notes become the default. If that is Astra’s default, long-refactor harness assumptions change: lean less on “crush everything into one summary.”
3. Price and quotas. Astra’s $10/$50, the 272K switch, the Sol promo end date, and ChatGPT Work / Codex quotas. DevDay has a history of moving a price tier or adding a Fast tier in the keynote.
4. Hosted Sandbox specs and partners. More memory, shorter cold starts, GPUs, or a new VPC partner would change which jobs you can drop on openai_hosted.
5. ChatGPT surface entry points. Whether Plus sees GPT-6 Pro in regular Chat, and whether Enterprise stays off by default. If the entry moves, internal training docs have to change the same day.

Do not expect something named GPT-7 on the 29th. The likelier story is: fold the four pieces already live in early September into one “model to sandbox to orchestration” developer narrative, then flip two or three switches.

How developers should prepare before the event

• Run a minimal Agents session first. Astra + openai_hosted + one job that writes a file and runs a command. During the livestream, compare “what they demo” with “what your account can already call.”
• Lock one eval set. Same repo, same tests, same timeout: Sol vs Astra vs your current Claude / Gemini route. Do not let model swaps fight daily development for the same machine.
• Split the bill into three lines. Model tokens, built-in tools, containers. Without those three lines, any DevDay “cheaper” claim will not match your invoice.
• Upgrade Codex CLI / Desktop. Old clients hide models. Turn the notes experiment on in config.toml now so you can compare default behavior on the 29th.
• Separate Linux sandbox from macOS acceptance. Scripts, front-end, and data work can go to Hosted Sandbox; xcodebuild, the simulator, and signing stay on Cloud Mac or a local Mac.
• Do not change the default route for a keynote. Wait 24 hours after the show for the docs to settle before you change the production model field. Keynote aliases often take a night to land on the model page.

Why long-running agents belong on Cloud Mac

Agents API solves orchestration. Hosted Sandbox solves generic Linux execution. Apple developers still need a third layer: the session cannot drop, you need a real macOS toolchain, disk and memory have to be enough, and it is best if CI lives on the same box.

• Stay awake: hour-scale and overnight jobs cannot survive laptop sleep. Desktop Work may still sync context to the cloud, but xcodebuild and the simulator can only be accepted on a Mac.
• Real toolchain: after Apply patch edits Swift, tests must run on the same machine. A GitHub-hosted macOS cold start stretches the agent feedback loop.
• Side-by-side evals: Astra vs Sol vs Fable 5 needs the same scripts in parallel. Local GPU / RAM folklore blows up first.
• Split work with openai_hosted: generic scripts, data, and front-end QA go to the hosted sandbox; iOS / macOS builds, certificates, and DerivedData go to Cloud Mac. Do not let one environment pretend it can do all of it.

The model ID may change again next year. The host and workflow do not need a rewrite. Put Codex / Agent loops on Vuncloud Cloud Mac and keep the laptop for reviewing diffs—that is the shared physical layer of 2026 flagship models, not an add-on for one vendor.

FAQ

When is OpenAI DevDay 2026?

Tuesday, September 29, 2026, at Fort Mason in San Francisco. The keynote starts around 10:00 a.m. with Sam Altman and is free to stream online. In-person registration is closed.

Will GPT-6 Astra launch that day?

Not as a debut. Astra was announced on September 3 and the API went live on September 4. The 29th is more likely to cover scale-up, Codex defaults, and Agents integration.

Can I use the Agents API now, and what does it cost?

Yes—public beta on September 10. The interface has no extra fee; you pay model tokens, tools, and containers. Astra standard short context is $10 / $50 per million tokens.

What is Hosted Sandbox?

An OpenAI-hosted Linux workspace. Set environment.type to openai_hosted. It ships with Python, Node, and a CLI; the directory is /workspace. For a custom image, GPU, or private network, use self_hosted or a partner.

How do Codex and the Agents API relate?

The Agents API turns Codex’s open-source harness into a hosted API. Local CLI / Desktop still work on their own; OpenAI operates the same orchestration on the API side.

What should you watch on the 29th?

Whether Agents goes GA, whether Codex notes become the default, price and quotas, sandbox specs / partners, and ChatGPT surface entry points. Trust that day’s site and docs for the full list.

Closing

Three sentences: the 29th is a consolidation day, not Astra’s birthday; Agents API + Hosted Sandbox can already close a minimal loop; keep the default route on Sol and step up for hard cases. Lock an eval set, a three-line bill, and a current Codex client before the show, or you will not hear which knob they are turning.

Model names will change again. What you actually need is an execution environment that stays up, and an upgrade rule written in plain language.

Further reading

• What is GPT-6 Astra? Features, pricing, API, and ChatGPT entry points
• How to buy AI Agent compute more cheaply in 2026
• LLM pricing and performance guide
• Codex weekly limit exhausted: what to do and alternatives
• 2026 AI coding tools ranking