OpenAI DevDay on September 29, 2026 brings model updates, ongoing agents, and more ways to build developer workflows. For an application team, the useful question is which announcement changes a measurable constraint: cost, completion quality, integration effort, or the amount of supervision a task needs. This field note reviews confirmed launch material and turns it into a practical evaluation plan.
The announcements that change engineering decisions
The official DevDay recap covers GPT-6.1 Sol, dots, Codex cloud workflows, plugin extensions, and new developer capabilities. Two distinctions matter immediately: the Decisions API is in limited preview, while GPT-6.1 Sol Ultrafast is described as coming soon. An announcement and access for a particular account are separate facts.
OpenAI's GPT-6.1 Sol launch article lists standard API prices of $2 per million input tokens, $0.10 per million cached input tokens, and $10 per million output tokens. It positions the model near Astra on selected evaluations at lower prices. Those comparisons are company-reported results; they are not measurements of this portfolio or a guarantee about another team's workload.
My interpretation is that cheaper capable models make more workflows worth testing. They do not remove the need to define success. A task that produces an attractive answer but changes the wrong record is still a failed task.
Evaluate the completed task before the token bill
A useful evaluation set contains real work with an observable endpoint. For a coding assistant, that might be a reviewed patch that passes a focused regression check. For document processing, it might be a validated extraction with citations to the correct pages. Avoid scoring only whether the response looks fluent.
Keep a fixed sample of ordinary cases alongside difficult ones. Include missing information, conflicting documents, unavailable tools, and tasks that should stop for clarification. Record which model and configuration handled each case, how many attempts were needed, and whether a person had to repair the result. Compare results under the same acceptance rules.
Token prices then become one part of a larger accounting model. Track tool charges, runtime, retries, and review effort where those costs apply. Cache savings are meaningful only when your actual requests benefit from caching. A public price table alone cannot establish the cost per accepted result.
- Accepted outcomes on real tasks
- Incorrect external actions
- Human repair effort
- End-to-end completion time
- Total cost per accepted result
Proposed evaluation priorities, not published OpenAI benchmark scores or results measured by this portfolio.
Begin with a narrow comparison rather than migrating every workflow. Keep the existing path available, run the same sample through the candidate, and inspect disagreements. If the new model handles routine cases well but struggles with a specific document type, route that category deliberately instead of averaging the problem away.
Ongoing agents need a durable work record
OpenAI's dots announcement describes agents with their own cloud computer, connected applications, and the ability to work across ongoing responsibilities. Rollout depends on plan, market, and workspace settings. The article also describes access controls and approval mechanisms. It should be read alongside the current settings for the account that will actually run the work.
For a team building an analogous workflow, I would define a durable record for each task: purpose, permitted tools, last completed step, pending decision, and final evidence. This is my proposed application design. It is not a description of undisclosed dots internals.
The record should survive a worker restart. If an agent drafts a support response, the system must distinguish drafting from sending. If a connection drops after a write, the next attempt should check the resulting state before repeating it. A task identifier and an external operation identifier can help connect the user's request to the final outcome.
- ScopeRecord goal and permissions
- ExecuteRun bounded tool operations
- VerifyRead the resulting state
- ReportAttach evidence and remaining decisions
Conceptual application workflow proposed by the author; it does not depict OpenAI's internal implementation.
A clear completion report is part of the product. It should state what changed, where the result lives, and whether any step failed. For recurring work, notify on a meaningful change or a decision that needs attention. Repeated messages that say nothing changed train people to ignore the system.
Decide what the pilot must be allowed to do
Before enabling an ongoing agent, separate a read-only investigation from a change to a shared system. A pilot can retrieve a document and draft a proposal without gaining authority to send messages or alter records. If a later step needs a write, show the intended target and proposed change, then verify the resulting state after approval. A retry after a timeout should check whether the first attempt already succeeded.
The DevDay recap describes announcements and rollout stages; it does not replace the permission settings or pricing visible to the account running the pilot. Keep an owner, a rollback path, and a representative set of failed cases alongside successful ones. These are proposed controls for an application team, not claims about undisclosed platform internals.
Put the September timeline in order
The Agents API introduction is dated September 10, 2026. It describes a managed harness, long-running sessions, tools, and execution environments. DevDay's recap adds computer-use support to that existing product. Calling the entire Agents API a September 29 invention would blur the release history.
For an integration, separate the model from the harness and the execution environment. The model decides what to do next; the surrounding application controls which tools exist, how state is stored, and how outcomes are checked. A managed service can take over parts of that infrastructure while your product still owns its user experience and acceptance criteria.
Plugin extensions are another decision about where a workflow belongs. Before creating a panel, identify the action a person needs to take there: compare alternatives, approve a draft, inspect a file, or correct a record. Build the smallest surface that makes that action understandable. A panel filled with generic status cards may add complexity without improving the task.
Price a request, then design its receipt
OpenAI's Sol launch pricing lists $2 per million input tokens, $0.10 per million cached input tokens, and $10 per million output tokens. Here is a worked illustration using those published rates, not an observed bill. Assume a request has 10,000 input tokens and 2,000 billed output tokens, with 8,000 of the input tokens eligible for a cache hit.
| Component | No cache hit | 8,000 cached input tokens |
|---|---|---|
| Uncached input | 10,000 × $2/M = $0.020 | 2,000 × $2/M = $0.004 |
| Cached input | $0 | 8,000 × $0.10/M = $0.0008 |
| Billed output | 2,000 × $10/M = $0.020 | $0.020 |
| Token total | $0.040 | $0.0248 |
This excludes tools, runtime, retries, and review. It also assumes the stated output count includes all billed output; visible answer length alone is not enough to reconstruct an invoice. Cache eligibility and actual usage need to come from the response and billing records. The calculation gives a unit-cost model, not a forecast that every task costs the same.
For an ongoing workflow, the more valuable artifact is often a receipt. Suppose the task is to prepare a weekly project update. I would record the task ID, approved source set, source timestamps, draft location, pending publication decision, and final external operation ID if sending is authorized. Keep “draft prepared” distinct from “update published.”
A connection loss after publication is the difficult case. Before retrying, look up the operation or resulting record. If it already exists, return that receipt instead of sending again. If the outcome cannot be determined, surface the uncertainty rather than inventing completion. This is proposed application behavior; it is not a description of OpenAI's internal agent implementation.
That combination—a transparent unit-cost calculation and a durable result record—makes a pilot easier to evaluate. A team can see both what the model consumed and what the user actually received. It also gives the next run a reliable starting point instead of relying on a fluent summary of an uncertain previous action.
November 2026 evidence update
Reviewed November 9, 2026 against the DevDay recap, Sol pricing, and the September 10 Agents API introduction. The token worksheet is a calculation from stated launch rates; it excludes tools and runtime. Preview availability and account access should be rechecked before integration.
Sources and further reading
- DevDay 2026 recap — September 29 launch and preview distinctions.
- GPT-6.1 Sol introduction — published prices and evaluation conditions.
- Agents API introduction — September 10 release history.
- Dots introduction — ongoing agents and access conditions.