Latest in AI
OpenAI Agents API Adds Auto Review, Time Awareness and Background Compaction
Five updates target the practical work of running persistent agents, from reviewing commands to keeping sessions responsive and reducing repeated prompt costs.
OpenAI's Agents API team announced five updates on October 30: automatic command review, background compaction, experimental time awareness, tools that can change during a session, and automatic system-prompt caching across sessions. The changes target how agents run over time, rather than introducing a new model.
For a developer building an agent that works through a task across many steps, that is useful territory. The model needs more than a good answer: it needs to manage context, execute actions carefully and avoid spending the same time and money repeatedly.
What changed in the Agents API
In a weekly update shared by OpenAI Developers, the team described the changes as follows:
| Update | Announced behavior |
|---|---|
| Auto Review | Evaluates commands for potentially problematic behavior before execution. |
| Async Compaction | Allows context compaction to happen in the background. |
| Time awareness | An experimental capability intended to improve behavior on time-bounded requests. |
| Tool updates | Allows a session's tools to be updated at any time. |
| Prompt-cache awareness | Automatically caches system prompts across sessions. |
The announcement does not provide measured speed improvements or a percentage cost reduction. These are capabilities to evaluate in a real workload, rather than a published performance comparison.
Why these changes belong together
The Agents API documentation describes a managed agent harness: OpenAI handles session orchestration, context management and recovery, while the application supplies its tools and execution environment. Sessions retain state across turns.
Consider an agent working on a failing build. It may read logs, change a file, run tests and repeat. As that work continues, the history grows and the useful tools can change. A tool needed to inspect a problem may be different from one that is appropriate for making a change.
Background compaction could reduce interruptions while that history is condensed. Updating tools during the session could let the application adapt the available actions without treating every workflow change as a fresh conversation. Those are practical design possibilities, not evidence that every existing integration becomes faster automatically.
Time awareness still needs application-level limits
The team's example for time awareness is an instruction to spend a limited number of minutes fixing continuous-integration failures. It is explicitly experimental.
A model understanding a time budget should not be treated as a guaranteed execution deadline. An application with a hard cutoff should enforce that cutoff itself. It should also decide what to do with unfinished work: save it, return a partial result or stop an external process.
Auto Review deserves the same distinction. A command-review step can be useful, but it should sit alongside restricted permissions and checks on consequential actions. Developers still need to decide which files, credentials and systems an agent can reach.
Caching changes the cost of repetition, not the model's price
OpenAI's prompt-caching guide explains that cache reuse depends on matching prompt prefixes. Changes earlier in a prompt can prevent reuse further along it. Compaction can also change which parts match.
That makes stable instructions worth separating from information that changes with each task. A repeated system prompt is a different cost opportunity from a new repository snapshot or fresh customer message. Teams should inspect actual cache usage before estimating savings from the new behavior.
The Agents API's documented billing still follows the chosen model's API rates, with standard charges for applicable tools and hosted sandbox containers. The weekly update does not announce a new price list.
The useful evaluation now is a complete task: how long it takes, what it costs, which actions are reviewed and what survives an interruption. Better session management matters when it makes that whole workflow more predictable, not just when it improves one model call.
I'm Paras. I work at the intersection of AI, engineering and distribution.
I help technical founders explain agent infrastructure and product updates in clear stories that developers can understand and share.