Until recently, the practice of building AI agents was like training a long-distance runner with a thirty-second memory.

Yes, you can give your AI models tools and instructions, but after a few dozen interactions – several laps around the track, to extend our running analogy – it inevitably loses context and starts imagining.

With The latest OpenAI updates to it Responses API — the application programming interface that allows OpenAI platform developers to access multiple agent tools such as web search and file search with a single call — the company is signaling that the era of the limited agent is waning.

Updates announced today include Server-side Compaction, Hosted Shell Containers, and a new one "Skills" standard for agents.

With these three major updates, OpenAI effectively provides agents with a permanent desk, terminal, and memory that doesn’t fade and helps agents evolve into reliable, long-term digital workers.

Technology: overcoming ‘context amnesia’

The most important technical hurdle for autonomous agents has always been "widespread" of long-standing tasks. Every time an agent calls a tool or runs a script, the conversation history grows.

Eventually, the model hits its mark limit, and the developer is forced to cut back on history—usually deleting the "REASONING" the agent must finish the job.

OpenAI’s answer is Server-side Compaction. Unlike simple cutting, compaction allows agents to run for hours or even days.

Early data from the e-commerce platform Suggested by Triple Whale it was a feat of strength: their agent, Moby, successfully navigated a session involving 5 million tokens and 150 tool calls without a drop in accuracy.

In practical terms, this means that the model can "summarize" its own past actions into a compressed state, keeping the important context alive while cleaning out the noise. It transforms the model from a forgettable assistant to a continuous system process.

Managed cloud sandboxes

The introduction of the Shell Tool moves OpenAI into the field of computational management. Developers can now choose container_auto, which provides an OpenAI-hosted Debian 12 environment.

It’s not just a code interpreter: it gives each agent its own full terminal environment pre-loaded with:

• Native execution environment including Python 3.11, Node.js 22, Java 17, Go 1.23, and Ruby 3.1.

• Continuous savings through /mnt/dataallows agents to create, store, and download artifacts.

• Networking capabilities which allows agents to reach out to the internet to install libraries or interact with third-party APIs.

The Hosted Shell and its constant /mnt/data Storage provides a managed environment where agents can perform complex data transformations using Python or Java without requiring the team to build and maintain custom ETL (Extract, Transform, Load) middleware for each AI project.

By using these hosted containers, data engineers can execute data processing tasks with high performance while minimizing "many responsibilities" which involves managing specialized infrastructure, removing the overhead of building and securing their own sandboxes. OpenAI actually says: “Give us the instructions; we’ll provide the computer.”

OpenAI Skills vs. Anthropic Skills

As OpenAI races toward a unified agent orchestration stack, it faces a significant philosophical challenge from Anthropic’s Agent Skills.

Both companies share a remarkably similar file structure – using a SKILL.md (markdown) reflected in the YAML frontmatter – but their underlying strategies reveal different visions for the future of work.

OpenAI’s approach is primarily a "programmable substrate" optimized for developer speed. By combining shell, memory, and Responses API capabilities, they offer a "turnkey" experience for building complex agents rapidly.

Already, business AI search startup glean reported a jump in tool accuracy from 73% to 85% by using the OpenAI Skills Framework.

In contrast, Anthropic launched Agent Skills as an independent open standard (agentskills.io).

While OpenAI’s system is tightly integrated with its own cloud infrastructure, Anthropic’s skills are designed for flexibility. A skill built for Claude can theoretically be transferred to VS Code, Cursor, or any other platform that adopts the specification.

In fact, the hit new open source AI agent OpenClaw adopted it exactly SKILL.md manifest and folder-based package, which allows it to inherit a wealth of specialized method knowledge originally designed for Claude.

This architectural compatibility inspires a community-driven "skills boom" on platforms like ClawHub, which currently hosts over 3,000 community-built extensions ranging from smart home integrations to complex business workflow automations.

This cross-pollination shows that the "skills" becomes a portable, versioned asset rather than a vendor-locked feature. Since OpenClaw supports multiple models – including OpenAI’s GPT-5 series and local Llama instances – developers can now write a skill once and deploy it to a heterogeneous landscape of agents.

For technical decision makers, this open standard has become the industry’s preferred method of outsourcing and sharing "agent knowledge," moving past proprietary prompts to a shared, inspectable, and interoperable infrastructure.

But there is another important difference between OpenAI’s and Anthropic’s "Skills."

OpenAI uses Server-side Compaction to manage the active state of a long-running session. Anthropic uses Progressive Disclosure, a three-level system where the model initially knows only the names and descriptions of skills.

Full specifications and auxiliary scripts are loaded only when the task requires them. This allows multiple skill libraries—brand guidelines, legal checklists, and code templates—to exist without overwhelming the model’s working memory.

Implications for technical business decision makers

For focused engineers "rapid deployment and recovery," the combination of Server-side Compaction and Skills provides a huge productivity boost

Instead of building custom state management for each agent flow, engineers can use built-in compaction to manage time-consuming tasks.

Skills allowed "encapsulated IP," where specific refinement or special method knowledge can be modularized and reused in different internal projects.

For those tasked with moving AI from a "chat box" to a production-grade workflow—OpenAI’s announcement marks the end of "specialized infrastructure" era.

Historically, orchestrating an agent required significant manual scaffolding: developers had to build custom state-management logic to manage long conversations and secure, ephemeral sandboxes to execute code.

The challenge is no more "How do I give this agent a terminal?" BUT "What skills are allowed for users?" and "How do we audit the artifacts created on the hosted filesystem?" OpenAI provided the engine and the chassis; the job of the orchestra is to determine the rules of the road.

For security operations (SecOps) managers, giving an AI model a shell and network access is a high-stakes evolution. OpenAI’s use of Domain Secrets and Org Allowlists provides a defense-in-depth strategy, ensuring agents can call APIs without exposing raw credentials in the context of the model.

But as agents can be easily deployed through "skills," SecOps must be vigilant "malicious skill" which may introduce easy injection vulnerabilities or unauthorized data exfiltration channels.

How do businesses decide?

OpenAI is no longer just selling a "BRAINS" (model); it sells to "office" (the vessel), the "memory" (compaction), and the "training manual" (skills). For business leaders, the choice becomes clear:

• Choose OpenAI if you need an integrated, high-speed environment for long-term autonomous work.

• Choose Anthropic if your organization needs model-agnostic portability and an open ecosystem standard.

Finally, the announcements announced that the AI ​​had moved out of the chat box and into the system architecture, turning around "quick spaghetti" to maintainable, versioned, and scalable business workflows.

Source link