On October 22, 2026, the Agentic AI Foundation (AAIF), a foundation under the Linux Foundation, brought four projects under neutral governance: Anthropic’s Agent Skills skill format, OpenAI’s Open Responses specification, Hugging Face’s OpenEnv learning-environment framework, and Alibaba’s OpenSandbox sandbox. For companies, this means agent instructions, the way models are accessed, and the code execution environment can be built on open formats that do not belong to a single vendor. The risk of vendor lock-in goes down, but it does not disappear: each product’s compatibility still needs to be checked.
Prepared by AIrassvet October 24, 2026 for executives, CIOs, and process owners who are implementing AI agents or selecting a vendor for them. This analysis is based on the Linux Foundation press release, the projects’ own pages, and their repositories. We explain what the announcement changes for companies deploying agents and do not examine the technical setup of each project. We did not conduct our own tests of these projects.
Contents
- In Brief
- What Happened on October 22
- The Four Projects in Plain English
- Why This Matters for Business
- What the News Does Not Change
- What a Company Should Do Now
- Questions to Ask Your Vendor After This Announcement
- Frequently Asked Questions
- Source Materials
In Brief
- Date and location. The announcement was made on October 22, 2026, in San Jose at the AGNTCon + MCPCon North America conference.
- What was added. Agent Skills (Anthropic), Open Responses (OpenAI), OpenEnv (Hugging Face), OpenSandbox (Alibaba).
- Foundation scale. According to the press release, AAIF grew from three projects at launch in December 2025 to ten. Those already included Model Context Protocol (MCP), AGENTS.md, goose, the A2A protocol, Agent Router, and agentgateway.
- The main takeaway for companies. Agent skills, model requests, and isolated code execution now have open specifications governed by a foundation rather than a single vendor.
- What to do. Store agent instructions as portable skills in your own repository, separate business logic from a specific model API, run agent code in an isolated environment, and include these requirements in your vendor contract.
What Happened on October 22
In the Linux Foundation press release dated October 22, 2026, it says that AAIF accepted four new projects, bringing the foundation’s total to ten. The announcement was timed to coincide with the AGNTCon + MCPCon North America conference, which ran on October 22–23 in San Jose. The same news was also published on the foundation’s website.
The foundation describes the new projects as four layers of the “agent stack”:
- how agents get new skills — Agent Skills;
- how applications communicate with models from different providers — Open Responses;
- how agents are trained and evaluated — OpenEnv;
- where agents safely perform actions — OpenSandbox.
Important detail: all four projects were contributed by different companies. In the release, AAIF CTO Manik Surtani emphasizes that the foundation’s job is to provide a common home for standards where “no single company controls the outcome.” For customers, that is an argument that the formats will evolve openly rather than at the discretion of one vendor.
The Four Projects in Plain English
Agent Skills: agent skills as folders
Agent Skills — an open format in which an agent skill is stored as a folder. One file is required: SKILL.md: its header contains the skill name and description, and below that is the instruction for how to perform the task. You can also include scripts, reference documents, and templates alongside it.
According to the specification , the skill name can be up to 64 characters and may contain only lowercase Latin letters, numbers, and hyphens; the description can be up to 1,024 characters and must explain what the skill does and when to use it. Optional fields include license, environment requirements, metadata, and a list of preapproved allowed-tools. This last field is marked experimental, and support for it may differ across agents.
The agent loads skills in stages. At startup it reads only names and descriptions; when a task fits, it reads the full instruction; and it opens scripts and reference materials as needed. As a result, an agent can keep many skills available without overloading the model context — unlike one long prompt that is read in full with every request.
Open Responses: one request format for different models
Open Responses — an open specification for the interface to language models based on the OpenAI Responses API. It defines a common request and response schema, unified streaming events, and tool-calling rules. The project’s goal is to define a request once and run it across different providers with minimal rework. To verify compatibility, the specification includes a set of acceptance tests.
For business, this is a step toward making it so changing model vendors does not mean rewriting the agent. But the specification only works where the provider or gateway has implemented it. We covered how to build a unified model access layer today in the article “A Unified LLM API for Business”.
OpenSandbox: an isolated environment for agent actions
OpenSandbox — a sandbox platform for AI applications licensed under Apache-2.0. The agent gets an isolated environment where it can run code, execute commands, and work with files, a browser, or the desktop. Locally, the sandbox runs in Docker; in production, it runs in Kubernetes through a single API.
The repository description lists features important for enterprise security: outbound network access policies for each sandbox and a Credential Vault that lets the agent access external services without seeing real passwords and keys. There are SDKs for Python, Java/Kotlin, TypeScript/JavaScript, C#/.NET, and Go, a command-line utility, and MCP connectivity. Why an agent needs a sandbox and how to evaluate it is covered in the article “Sandbox for an AI Agent”.
OpenEnv: environments for training agents
OpenEnv — an open framework for reinforcement learning (RL) environments. The environment is packaged in a container and gives the agent a familiar interface, including MCP and the Gym protocol used by training libraries. Most companies will need OpenEnv later than the other projects: it is for organizations that fine-tune agents on their own scenarios or build test beds to evaluate them.
Summary table
| Project | Who contributed it | What problem it solves | Who benefits most from it |
|---|---|---|---|
| Agent Skills | Anthropic | Portable Skills and Agent Instructions | For anyone documenting agent operating procedures |
| Open Responses | OpenAI | A unified request format for models from different providers | For teams that want to switch models without rewriting the agent |
| OpenSandbox | Alibaba | Isolated execution of code and agent actions | For teams where the agent runs code, uses a browser, or works with files |
| OpenEnv | Hugging Face | Training and evaluation environments for agents | For teams that fine-tune and test agents |
Why this matters for business
Company knowledge is no longer tied to a single platform. A request-handling procedure, contract review rules, or an 1C reconciliation workflow, documented as a skill, becomes a file in your repository. You can version it, review it, and connect it to any agent that supports the format. If your agent platform vendor raises prices or exits the market, there will be less to move.
Switching models gets cheaper. Companies in Russia often run several models: a domestic one in the cloud, an open model on their own servers, and a foreign one through a gateway. A common request specification reduces the amount of adapter code between them, if providers support it. The same principle underlies the AI service exit plan: knowing in advance what migration will cost.
Execution safety gets an open foundation. An agent that runs code or uses a browser should do so in an isolated environment with network restrictions. An open sandbox that can be deployed on your own servers is a good fit for companies that cannot move data outside their perimeter.
It is easier for the client to define requirements. Instead of the vague directive “make sure we can leave later,” the technical brief includes concrete items: skills in the Agent Skills format, model calls through a layer with an open specification, and code execution in a sandbox with network policies.
What the news does not change
- Neutral governance is not a guarantee of security. A skill can contain scripts, which means someone else’s skill is someone else’s code. It needs to be reviewed like any third-party dependency. The risks are covered in the article “Security for AI Agent Skills”.
- Compatibility is not automatic. The format is open, but every agent and every provider implements it differently. The
allowed-toolsfield in Agent Skills is experimental, and Open Responses works only for those who have passed its tests. - Agent quality is still determined by the process. An open format will not fix an inaccurate procedure, messy data, or the lack of an acceptance criterion.
- Support from Russian platforms has not been confirmed. For example, the GigaChat documentation (updated June 25, 2026) describes only partial compatibility with the OpenAI API. As of October 24, 2026, we did not find public statements from domestic providers confirming successful Open Responses acceptance testing. This should be clarified with each vendor separately.
What a company should do now
- Create an inventory of agent instructions. Collect the prompts, procedures, and scenarios your AI assistants and agents already use, and note where they are stored: in code, in platform settings, or in employees’ heads.
- Convert repetitive instructions into skills. Start with one process: create a folder with
SKILL.md, a clear “when to use it” description, examples, and scripts if needed. Store it in the company repository with change history. - Separate business logic from the model API. Have the agent access models through a single internal layer or gateway. Then switching to Open Responses or changing providers can be done in one place.
- Move code execution into a sandbox. If the agent runs scripts, opens a browser, or works with files, do it in an isolated environment with unnecessary network access blocked and no real keys inside.
- Review third-party skills like code. Before connecting a skill from an external catalog, review its scripts, environment requirements, and list of allowed tools.
- Put the requirements into the contract. Specify that skills, configurations, and test scenarios are delivered to the client in an open format and remain with them after the work is completed.
Questions to ask the contractor after this news
| Question | Good answer |
|---|---|
| In what format are the agent instructions stored? | In the client’s repository, in an open format (for example, Agent Skills), with version history |
| What happens if we change the model? | The model changes in one access layer; business logic and skills do not need to be rewritten |
| Where does the agent execute code and browser actions? | In an isolated environment with network restrictions; keys are not passed into the environment |
| How do you review third-party skills? | Review scripts and allowed tools before connecting; test in a sandbox |
| What will we keep after the project? | Skills, configurations, test suite, and documentation in open formats |
Frequently asked questions
What is the Agentic AI Foundation?
The Agentic AI Foundation (AAIF) is a Linux Foundation-backed organization that governs open standards and tools for AI agents. It launched in December 2025 with three projects, including MCP, goose, and AGENTS.md. After the October 22, 2026 announcement, it was placed under its governance with ten projects, including Agent Skills, Open Responses, OpenEnv, and OpenSandbox.
How is Agent Skills different from MCP?
MCP connects an agent to external tools and data: databases, CRM systems, files. Agent Skills describes how to perform a specific task: the instructions, examples, and supporting scripts in one folder. Put simply, MCP gives the agent access to systems, while a skill explains what to do with that access. In real-world agents, these approaches are usually used together.
Can skills already be transferred between different agents?
Yes, if both agents support the Agent Skills format, but check the details. The required part of the format is simple: a folder with the SKILL.mdfile, a name, and a description. Support for experimental fields such as allowed-toolsand script execution may differ. Before migrating, run the skill on a test task in the new agent.
Does a company need to switch to Open Responses?
There’s no need to switch immediately, but you should start preparing the architecture. It’s enough for agents to access models through a single internal layer. Then, when your providers support the specification and pass its acceptance tests, the migration will affect only that layer. Until then, the layer continues translating requests into each provider’s API.
Is OpenSandbox suitable for an air-gapped environment?
Based on the repository description, yes: OpenSandbox is distributed under the Apache-2.0 license and can be deployed on your own infrastructure in Docker or Kubernetes. But compliance with your security team’s requirements must be checked separately: network settings, log storage, updates. We have not tested OpenSandbox ourselves.
Primary sources
- Linux Foundation press release from October 22, 2026 — date, project list, participant quotes.
- News on the AAIF website.
- Agent Skills documentation and the format specification.
- Open Responses specification site.
- OpenSandbox repository.
- OpenEnv repository.
All pages were checked on October 24, 2026. Compatibility assessments and recommendations are our conclusions from these documents, not the results of our own testing.
How AIrassvet helps prepare AI agents for open standards
For company knowledge to avoid staying trapped inside a single platform, it first needs to be documented and then connected to the agent correctly. Among the directions listed on the AIrassvet website, there are services that cover this work:
- process audit: analyzing the policies and instructions an agent must follow and turning them into portable skills;
- development of AI agents integrated with communication channels and business systems, with a separate model access layer;
- deployment of LLMs on on-premises servers for tasks where data cannot leave the secure environment;
- testing the agent before launch using the client’s scenarios.
The first step is to choose one process and document the current outcome, data sources, constraints, and acceptance criteria.
Bottom line: open formats reduce lock-in, but validation is still on you
On October 22, 2026, Agent Skills, Open Responses, OpenEnv, and OpenSandbox moved under the neutral governance of the Agentic AI Foundation. Agent skills, model requests, and isolated code execution are now defined by open specifications that are not controlled by a single vendor.
The practical takeaway for companies is simple: store agent instructions as skills in your own repository, call models through a single internal layer, run agent code in a sandbox, and treat every third-party skill like code. That way, switching platforms or models will cost less, and you’ll be able to adopt new standards as soon as your providers support them.
