Four companies that compete for the same AI developers just handed pieces of their agent technology to a shared home. On October 22, 2026, the Agentic AI Foundation announced four new projects at AGNTCon + MCPCon North America in San Jose. They are Agent Skills from Anthropic, Open Responses from OpenAI, OpenEnv from Hugging Face, and OpenSandbox from Alibaba (AAIF announcement, Agentic AI Foundation, retrieved 2026-10-26). Together they take the foundation from three launch projects in December 2025 to 10 hosted projects in its first year. That number matters less than what the four cover: how agents learn a skill, how apps talk to models, how agents are trained, and where their code runs safely.
Key Takeaways
The Agentic AI Foundation announced four new projects on October 22, 2026, taking it from three launch projects in December 2025 to 10 hosted projects.
Agent Skills, donated by Anthropic, is an open format for packaging agent know-how. Anthropic reports 1 million skills published and nearly 280 million installed, with more than 70 agent platforms integrated.
Open Responses, donated by OpenAI, is an open specification for multi-provider model interfaces, based on the OpenAI Responses API, so a request can be described once and run across providers with minimal translation.
OpenEnv, donated by Hugging Face, is an open framework for reinforcement learning environments, with a Gymnasium-style API and containerized environments you can deploy locally or in the cloud.
OpenSandbox, donated by Alibaba, is a general-purpose sandbox platform with multi-language SDKs and Docker and Kubernetes runtimes, released under the Apache 2.0 license.
The four projects join six existing AAIF projects. They are the Agent2Agent protocol, Agent Router, agentgateway, AGENTS.md, goose, and the Model Context Protocol, known as MCP. Anthropic had already donated MCP to the foundation. This announcement extends a pattern rather than starting one. Manik Surtani is the foundation's CTO and co-founder. He framed the move as a community bet: AAIF announcement quotes him saying the foundation exists to give the community one place to build shared standards, protocols, and infrastructure, with no single company controlling the outcome.
What Is the Agentic AI Foundation?
The Agentic AI Foundation (AAIF) is a Linux Foundation project that hosts open standards, protocols, and infrastructure for agentic AI. Agentic AI means AI that carries out multi-step tasks on its own, rather than only answering a question. The foundation describes itself as the neutral home for that work. Its governance is meant to be open and vendor-neutral. In practice, a project donated to the AAIF is no longer steered by one company alone. Other companies and individual maintainers can help shape where it goes next.
Neutral governance is a promise about process, not a guarantee about influence. The donating companies wrote the code, so they will carry weight early on. What changes at donation is who gets a formal say.
Project | Donor | Layer | What it is |
|---|---|---|---|
Agent Skills | Anthropic | Capabilities | Open format for packaging instructions, scripts, and resources that agents load on demand |
Open Responses | OpenAI | Model interfaces | Open specification for multi-provider LLM interfaces, based on the Responses API |
OpenEnv | Hugging Face | Training and evaluation | Open framework and hub for reinforcement learning environments |
OpenSandbox | Alibaba | Safe execution | General-purpose sandbox platform with SDKs and Docker and Kubernetes runtimes |
Agent Skills: Teach an Agent Once, Reuse It Everywhere
Agent Skills is an open format for giving agents new capabilities and domain expertise. A skill is a folder that teaches an agent one specific task or domain. It contains a SKILL.md file with the instructions, plus any scripts or reference material the task needs. The agent loads the skill only when a task calls for it. The instructions do not sit in every conversation. That loading on demand is the whole point. Specialized know-how becomes portable across agent products and platforms, instead of being rewritten for each tool. For example, a skill can teach an agent your report format. Every report then follows the same headings and checks.
Anthropic built the format while working on Claude Code, where the general model handled broad knowledge work well but often lacked the procedural knowledge real business tasks need. Within weeks of the October 2025 launch, developers published thousands of skills and wrote loaders for Codex, Cursor, and OpenCode. Anthropic published the format as an open standard in December 2025. Since then, it reports, 1 million skills have been published and nearly 280 million installed. More than 70 agent platforms have integrated the format, including ChatGPT, Cursor, GitHub Copilot, and VS Code (Anthropic announcement, Anthropic, retrieved 2026-10-26). Treat those totals as the company's own figures. They show traction, not an independent audit, but the direction is clear: the format spread before the foundation got involved.
The donation moves more than a document. Anthropic is donating the Agent Skills name and logo, the GitHub organization, and the agentskills.io domain. Engineers from Anthropic, Google, OpenAI, and other companies will maintain the standard as individuals, with David Soria Parra and Mahesh Murag as lead maintainers. You can keep using the standard or contributing to it without joining the AAIF. One thing the donation does not do, according to independent coverage of the announcement, is change the specification itself. What changes is who governs it (DigitechInfo explainer, DigitechInfo, retrieved 2026-10-26).
Do not confuse the format with a library of skills. Our Scientific Agent Skills article covers a large collection of ready-made skills for science work. Agent Skills is the format those skills are written in. The collection is useful content. The format is the shared rulebook that lets the same content run in many tools.
One caution travels with the format. A skill can bundle executable scripts, so an unvetted skill is software, not just text. Check what a skill contains before you install it, and run anything executable inside a sandbox.
Open Responses: One Request Shape for Many Model Providers
Open Responses is an open specification for building multi-provider, interoperable LLM interfaces, based on the OpenAI Responses API. It defines a shared schema, consistent streaming events, and extensible tooling. Developers can describe requests and outputs once. They can then run them across model providers with minimal translation. Consider a small team that runs its app on one provider today. With a shared shape, it can test a second provider without rewriting every call.
The practical gain is choice at runtime: evaluate a new model, route by cost, or fail over to another provider without rewriting application logic. AWS says Amazon Bedrock already supports the Responses API across dozens of models, and that AWS employs a core maintainer on the project (AWS open source blog, AWS, retrieved 2026-10-26). That kind of provider support is what turns a specification from a document into a working option.
Open does not yet mean universal. Independent coverage notes that Anthropic is not listed as a backer of Open Responses, and that Google keeps its own Interactions API instead (daily.dev coverage, daily.dev, retrieved 2026-10-26). So check the fine print before you commit: find out which features your app uses are part of the common specification, and which are provider-specific extensions. A shared shape still helps, but it does not erase every difference between providers.
OpenEnv: A Shared Practice Ground for Training Agents
OpenEnv is an open framework and community hub for creating reinforcement learning environments. In reinforcement learning, an environment is the practice ground where an agent acts, observes results, and learns from rewards. The design of that environment matters as much as the model. It decides what the agent can see, what actions it can take, and what reward it gets back. When every training library invents its own environment protocol, the same practice ground cannot be reused. OpenEnv standardizes that interaction. For example, one environment can present a coding task. Another can present a browser task. The same training system can run both.
The framework exposes a familiar agent interface, MCP, and Gym, the training protocol that training libraries use, through a simple containerized service. Its Gymnasium-style API uses reset() to restart an environment, step() to run one action, and state() to report the current state. Each environment is a Docker image that runs locally, on a cloud sandbox, or as a Hugging Face Space. The project lists more than 40 ready-to-use environments, from games and coding sandboxes to browsers, finance, and simulators (huggingface/OpenEnv, GitHub, retrieved 2026-10-26).
The committee behind OpenEnv names Hugging Face, Microsoft, Reflection, Meta-PyTorch, Fleet, Mercor, RadixArk, Modal, Prime Intellect, and more. For a team that trains agents, the value is reuse: build an environment once, share it through the hub, and let other training systems run it without a custom adapter for each one.
OpenSandbox: A Locked Room Where Agent Code Can Run
OpenSandbox is a general-purpose sandbox platform for AI applications. A sandbox is an isolated environment where an agent can run code, browse, or control software without touching your live systems or production data. OpenSandbox offers multi-language SDKs, unified sandbox APIs, and Docker and Kubernetes runtimes. It covers coding agents, GUI agents, agent evaluation, AI code execution, and reinforcement learning training. It also includes a sandbox protocol that defines lifecycle and execution APIs, so teams can extend it with custom runtimes. For example, an agent can run code it just wrote inside a sandbox. It returns only the result. Your live systems stay outside.
Docker suits local work and single-node deployments. Kubernetes suits distributed deployments at scale. If Kubernetes itself is new to you, our Kubernetes explainer covers what it is and why it runs the cloud. The project is released under the Apache 2.0 license, and its source, SDKs, server, specs, and examples are on GitHub (alibaba/OpenSandbox, GitHub, retrieved 2026-10-26).
Why This Matters, and What It Does Not Settle
The methodology of this article is simple. We compared the official announcement with independent coverage. We then checked company-claimed numbers against their own sources. That comparison is the basis for the claims below.
The strongest argument for the AAIF bet is the lack of lock-in. Put external tools behind MCP, package repeatable procedures as versioned skills, and route model calls through the Open Responses shape. Then a price rise, a latency change, or a policy shift at one provider does not force a rewrite.
Three questions remain open, and honest coverage flags all three. First, the announcement names only the four donors. It does not list AAIF member companies, so the full governance picture is not yet public (DigitechInfo explainer). Second, the press release does not link to the project repositories, so builders still have to find the code through the projects themselves. Third, vendor-neutral governance will be tested by who actually maintains these projects over the next year. Watch the maintainer lists, not just the launch logos.
Security is the fourth open question, and it cuts across the stack. Skills can carry scripts, sandboxes can have gaps, and model interfaces can leak provider-specific behavior. The safe pattern is simple: review skills before installing them, run executable agent code inside a sandbox, and test provider switches before you depend on them.
Who Should Act Now
Different builders should take different first steps:
If you write agent procedures, write your next one as a SKILL.md file. It is plain text with frontmatter, and it will now be governed as a shared standard rather than one company's format.
If you build apps on model APIs, prototype one call through the Open Responses shape and check which of your features are common and which are provider-specific.
If you train agents, look at OpenEnv before building another custom environment adapter. Reuse beats reinvention when the environment is the hard part.
If you run agent code, test OpenSandbox locally with Docker before you let an agent near real accounts or live data. Containment is a feature you verify, not a label you trust.
Frequently Asked Questions
Is the Agentic AI Foundation a new organization? No. The foundation launched in December 2025 with three projects: MCP, goose, and AGENTS.md. The October 22, 2026 announcement adds four projects and takes the total to 10. The four projects are new to the foundation, not the foundation itself.
Do I have to join the AAIF to use Agent Skills? No. Anthropic says you can continue to use the standard or contribute to it without joining the AAIF. The donation moves governance to a neutral home, not access behind a membership wall.
Is Open Responses the same as the OpenAI Responses API? No. Open Responses is an open specification based on the Responses API. It defines a shared schema, consistent streaming events, and extensible tooling for multi-provider use. The Responses API is one provider's API. Open Responses is the shared shape built on top of it.
What is OpenEnv used for? OpenEnv is used to create, share, and run reinforcement learning environments: the practice grounds where agents are trained and evaluated. It standardizes how training systems talk to those environments, using a Gymnasium-style API and containerized deployments.
Does OpenSandbox make agent code safe by itself? No. OpenSandbox provides isolation, SDKs, and runtimes, but safety depends on how you configure it: network access, file access, resource limits, and which runtimes you choose. Treat it as a containment tool to verify on your own setup, not as a guarantee.
The Bottom Line
Rivals rarely share their best plumbing. When they do, it is usually because the alternative is worse: ten incompatible ways to do the same thing, each owned by a different vendor. The AAIF announcement is a bet that agents will grow faster on shared rules than on closed ones. That choice does not settle governance, security, or provider coverage. Those will be decided by maintainers, adopters, and the next year of real use. For now, learn the four pieces, audit where your stack is locked to one vendor, and start with the piece that removes the most lock-in for you. Start with the AAIF announcement, Anthropic's Agent Skills donation post, the OpenEnv repository, and the OpenSandbox repository, or read the Indonesian version of this article.