On October 22, 2026, the Agentic AI Foundation (AAIF) announced that four new projects covering AI agent work procedures and execution environments are joining it. They include Anthropic's "Agent Skills" and OpenAI's "Open Responses." With these additions, the AAIF now oversees 10 projects, up from the three it launched with in December 2025. Beyond standardizing connections between AI models and external tools, the vendor-neutral governance structure now extends to technologies that support agent training and evaluation, as well as secure execution environments. However, even if adopting common specifications improves compatibility between different products, that does not guarantee identical behavior or safety in every environment.
The four new projects and their roles
The four new projects address different technical areas that make up an AI agent. Agent Skills covers the work procedures given to an agent, Open Responses covers communication with AI models, OpenEnv covers training and evaluation environments, and OpenSandbox covers building and managing secure execution environments. All are relevant to developing and operating AI agents, but each aims to standardize a different layer.
Based on the Linux Foundation's October 22 announcement and each project's official documentation, the roles and implementation checkpoints can be summarized as follows.
| Project | Contributed by | What it standardizes | What to check when implementing |
|---|---|---|---|
| Agent Skills | Anthropic | Work procedures bundling instructions, scripts, and reference materials | Tools and execution environments the skill requires |
| Open Responses | OpenAI | Format for requests to models, responses, and processing status | Scope of support for the common spec and provider-specific extensions |
| OpenEnv | Hugging Face | Interaction with training and evaluation environments, and how environments are distributed | Per-environment implementations and APIs that may change |
| OpenSandbox | Alibaba | Creating and managing isolated environments, and running processes inside them | Isolation features and network controls of each execution platform |
This classification organizes each project's main purpose; it is not a comparison of performance or maturity. In practice, some uses overlap: OpenSandbox can be used not only to run AI agents but also as a reinforcement learning training environment. Still, distinguishing which technologies are meant to be shared across products and execution platforms clarifies which specifications and compatibility ranges developers need to check.
The four join projects already in the AAIF, such as the Model Context Protocol (MCP), AGENTS.md, and goose. Agent2Agent (A2A), Agent Router, and agentgateway are also participants, bringing the AAIF's total to 10 projects. The significance of this announcement is not that four technologies have newly been developed or released, but that existing projects are moving from management by a single company to vendor-neutral joint governance.
Agent Skills shares work procedures; Open Responses standardizes communication with models
Agent Skills is a mechanism for reusing, across different products, the procedures and knowledge that let an AI agent perform a specific task. The official specification defines a skill as a directory containing at least a file named SKILL.md. Work procedures are written in this file, and scripts, reference materials, and other resources can be stored in the same directory as needed. Rather than passing a long set of instructions to the model every time, the design bundles the information needed for a particular task so it can be used when required.
One feature of Agent Skills is that it loads information in stages. The agent first decides whether a skill is relevant based on its name and description, then loads the procedures in SKILL.md only when it actually uses the skill. Attached scripts and reference materials are consulted only when needed. This approach lets specialized knowledge be managed together without loading all of it into the model's context at all times.
However, even if the format for describing procedures is standardized, the tools and environments needed to carry them out are not. The specification also provides a compatibility field for describing target products and system requirements. When a developer moves a skill written for one AI agent to another product, they must confirm not only that SKILL.md can be read, but also that the attached scripts can run and that the required tools and external services are available.
Open Responses, meanwhile, is a specification for standardizing communication between applications and AI model providers. Based on OpenAI's Responses API, it expresses requests sent to models, generated results, tool calls, and more in a common format. The Open Responses specification treats messages, tool calls, and similar elements as units called "items," and defines how to represent the content and state of each.
For responses in progress, it goes beyond simply receiving text sequentially and treats processing progress as meaningful events. For example, it can distinguish that a new output item has been added, that processing is under way, or that it has completed. With this common format, application developers can more easily absorb API differences between model providers and handle not only text generation but also tool execution status in a unified way.
That said, adopting Open Responses does not mean every model provider can be used in exactly the same way. The specification itself states that depending on fields a provider has added on its own reduces an application's portability. If an application uses a feature unique to one service, it may not work the same way on another Open Responses-compatible server. To make switching providers easy, developers need to know which of the features their application uses are part of the common specification and which are provider-specific extensions.
OpenEnv standardizes training and evaluation environments; OpenSandbox standardizes isolated execution
OpenEnv is a framework for creating and sharing training and evaluation environments in which AI agents act and receive the results. In reinforcement learning in particular, not only the model's performance but also the design of the environment matters: what actions can be taken, and what information and rewards are returned as a result. OpenEnv aims to standardize interaction with such environments so they can be reused more easily across different training systems and evaluation platforms.
Hugging Face's official documentation defines a common API that includes reset() to return an environment to its initial state, step() to execute an action and advance the environment, and state() to retrieve the current state. Environments can be distributed as Docker images and run locally or in the cloud. The aim is to reduce the burden of implementing a different connection method for each environment used in training and evaluation, and to make the same environment easier to use across multiple systems.
Environments that support MCP can also expose tools in a production-oriented mode. This opens the possibility of connecting the environments used for training and evaluation with the tools an agent actually uses. However, the official documentation states that OpenEnv is at an early stage of development and that its APIs may change. When adopting it, developers need to check not only how environments are distributed but also how stable the APIs and connection methods are in the version they choose.
OpenSandbox, by contrast, is a platform for building and managing isolated environments where AI applications run code or operate browsers and similar tools. It provides SDKs for multiple programming languages and a common API, and can use Docker or Kubernetes as its execution platform. In addition to code execution and browser operation by AI agents, it can be used for evaluation and reinforcement learning training, so its uses partly overlap with OpenEnv. However, whereas OpenEnv standardizes interaction with training and evaluation environments, OpenSandbox focuses on creating and managing isolated environments and running processes inside them.
OpenSandbox's architecture documentation separates the path that manages creating and deleting isolated environments from the path that runs commands and handles file operations. A mechanism for controlling communication from the isolated environment to external services is also provided as an independent component. This allows lifecycle management of the environment, processing inside it, and external communication to be treated as distinct roles.
Still, being able to create an isolated environment through a common API is a separate matter from that environment being sufficiently secure. The OpenSandbox documentation also explains that available features, such as execution capabilities and network controls, vary depending on the execution platform chosen. Adopting OpenSandbox therefore cannot, by itself, justify a uniform assessment of safety. In actual deployments, teams need to confirm concretely which execution platform is used, what is to be isolated, and how external communication is restricted.
What vendor-neutral governance changes, and the compatibility issues that remain
What changes most with these projects joining the AAIF is the governance structure: who decides the future of each project's specifications and implementations, and how. In the Linux Foundation's announcement, Alibaba said its purpose in joining is to let more developers and organizations take part in setting OpenSandbox's direction, rather than leaving its future to a single company. This can be seen as a move to build a decision-making process independent of any particular company, not only for standardizing technical specifications but also for changes and feature additions. As the technologies supporting AI agents come to be used across multiple companies and products, the question of who manages their specifications is growing in importance.
However, even with a vendor-neutral governance structure in place, simply combining different projects and products will not make every feature work without problems. Developers first need to understand the scope each specification covers and distinguish between what is standardized and what depends on individual implementations. If moving Agent Skills to another product, they must check the required tools and execution environments; if switching model providers with Open Responses, they must check for dependence on proprietary extensions. For OpenEnv and OpenSandbox as well, API versions, isolation features of each execution platform, and how external communication is controlled will be key factors in deployment decisions.
The growth of the AAIF's portfolio to 10 projects shows that standardization of the technologies supporting AI agents is widening from connections between models and tools to work procedures, training, and execution environments. But these will not become a single integrated product, and compatibility and safety across different implementations will still need to be verified individually. If adoption of common specifications advances and the range in which the same procedures and environments can be reused across products and execution platforms expands, developers should find it easier to choose an AI agent configuration that suits their use case without depending on a particular vendor.