Four New AI Agent Standards Explained: Agent Skills, Open Responses, OpenEnv, and OpenSandbox
What the Agentic AI Foundation's four new projects do, where each fits in an agent stack, how to try each one, and what to check before you adopt any of them.
On October 22, 2026, the Agentic AI Foundation (AAIF), hosted by the Linux Foundation, took on four new AI agent standards and tools: Agent Skills from Anthropic, Open Responses from OpenAI, OpenEnv from Hugging Face, and OpenSandbox from Alibaba. They do not compete. Each covers a different layer of an agent: Agent Skills packages reusable instructions, Open Responses gives you one request format for many model providers, OpenEnv gives you repeatable environments for training and evaluating agents, and OpenSandbox gives you an isolated place to run agent-generated code. This guide explains each one in plain terms, shows the first command or file for each, and lists what to check before you build on any of them. A neutral foundation home is good news for portability. It does not make every implementation compatible, mature, or production-ready, so each project still needs its own evaluation.
System requirements
Who this is for
Developers building or evaluating AI agents
You should know what a tool call and a model API request are. You do not need to have used any of the four projects.
Agent Skills
A text editor and a skills-compatible agent
A skill is a folder with a SKILL.md file. It works on Windows, macOS, and Linux. Whether bundled scripts can run depends on the agent you load it into.
OpenEnv
Python and pip
Install with pip install openenv. Each environment is a Docker image, so Docker is needed to run environments locally. Hosted Hugging Face Spaces work without it.
OpenSandbox
Docker and Python 3.10 or newer
The README lists Docker for local execution and Python 3.10+ for the local runtime and examples. Kubernetes is needed only for cluster deployments.
Open Responses
An API that implements the spec
Open Responses is a specification, not a package. You call a provider or local server that implements it. The project site lists implementations including OpenAI, Ollama, vLLM, OpenRouter, Hugging Face, and LM Studio.
Cost
Free and open source
OpenSandbox is Apache 2.0 and OpenEnv is BSD 3-Clause. Model tokens, cloud compute, and hosted sandboxes cost whatever your provider charges.
What is the Agentic AI Foundation, and what changed?
A Linux Foundation home for open agent standards. It now hosts 10 projects, up from three at launch in December 2025.
The AAIF gives open agent protocols and infrastructure a vendor-neutral home, so no single company controls their direction. Before this announcement it already hosted the Model Context Protocol (MCP), Agent2Agent (A2A), AGENTS.md, goose, Agent Router, and agentgateway.
The October 22 announcement added Agent Skills (contributed by Anthropic), Open Responses (OpenAI), OpenEnv (Hugging Face), and OpenSandbox (Alibaba), bringing the total to 10.
Foundation hosting is about governance: who owns the name, the repository, and the decision process. It says nothing on its own about maturity. OpenEnv's own docs say it is in early development and its APIs may change. Check each project's release status, licence, and maintainers before you depend on it.
Agent Skills: package reusable expertise in a folder
A skill is a directory with a SKILL.md file: a name and description up top, instructions below, and optional scripts and reference files.
Problem it solves: teams rewrite the same task instructions for every agent and every project. A skill packages that procedure once. Say your company wants every generated report to follow an internal template, use approved terms, and pass a validation step. That becomes one versioned folder that any skills-compatible agent can load.
The format is small. SKILL.md needs YAML frontmatter with name (up to 64 lowercase letters, numbers, and hyphens, matching the folder name) and description (up to 1024 characters, saying what the skill does and when to use it). Optional folders hold scripts/, references/, and assets/.
Agents load skills through progressive disclosure. At startup they read only each skill's name and description, about 100 tokens. When a task matches, they load the full SKILL.md body. Bundled files load only when the instructions call for them. That keeps many skills available without filling the context window.
Anthropic's donation moved the standard, the Agent Skills name and logo, the GitHub organization, and the agentskills.io domain to the AAIF. Engineers from several companies maintain it as individuals.
Watch out: an open format does not make a skill safe. Instructions steer the agent, and bundled scripts can run wherever the agent is allowed to execute code. Treat third-party skills like third-party code: read them, inspect the scripts, control who can change your skill repository, and limit what the agent may execute.
---
name: code-review
description: Reviews a code change for correctness, security, and
maintainability issues and reports findings in a fixed format.
Use when asked to review a diff, pull request, or patch.
license: Apache-2.0
---
# Code review
1. Read the diff and the files it touches.
2. Look for correctness, security, and maintainability problems.
3. Run the checks in scripts/run-checks.sh.
4. Report each finding as: file:line, severity, problem, evidence.
5. Follow references/style-guide.md for naming rules.mkdir -p skills/code-review/scripts skills/code-review/references
touch skills/code-review/SKILL.mdNew-Item -ItemType Directory -Force skills\code-review\scripts, skills\code-review\references
New-Item -ItemType File skills\code-review\SKILL.mdTip
The spec points to the skills-ref reference library for validation: skills-ref validate ./skills/code-review checks the frontmatter and naming rules before you share the skill.
Open Responses: one request format for many model providers
An open specification for calling language models, based on the OpenAI Responses API, so application code is less tied to one provider.
Problem it solves: an app built on one provider's API depends on that provider's request fields, streaming events, and tool-call shapes. Adding a second provider means translation code and more testing for request building, streamed output, tool-call parsing, errors, and response normalization.
Open Responses describes requests and outputs once. The core unit is the item: a message, a reasoning item, a function_call from the model, or a function_call_output that you send back, matched by call_id. Streaming events and tool invocation follow the same patterns across implementations. Provider-specific extras use a prefixed type such as openai:web_search_call, so they do not fragment the core.
The project publishes a spec, an OpenAPI reference, and acceptance tests for checking whether an API conforms. It lists implementations from OpenAI, NVIDIA, Vercel, OpenRouter, Hugging Face, LM Studio, Databricks, Red Hat, AWS, Ollama, vLLM, and Llama Stack.
Watch out: a shared format does not mean identical behavior. Providers still differ in tool support, multimodal input, context limits, error semantics, reasoning features, latency, and price. Test the exact features you rely on with each provider instead of assuming they are interchangeable.
{
"model": "your-model-id",
"input": [
{
"type": "message",
"role": "user",
"content": "Find the bug in fizz_buzz()."
}
]
}
// A tool call comes back as an item:
// { "type": "function_call", "name": "...", "call_id": "...", "arguments": "{...}" }
// You reply with { "type": "function_call_output", "call_id": "...", ... }OpenEnv: repeatable environments for training and evaluating agents
A framework for agent environments with a Gymnasium-style API: reset(), step(), and state(), served over a WebSocket from a Docker image.
Problem it solves: to train or evaluate an agent, you need a place where it can take actions, see the results, and get scored, under the same conditions every run. Building those environments by hand for each project is slow and hard to share.
Each OpenEnv environment is a Docker image that runs locally, on a cloud sandbox, or as a Hugging Face Space. Clients call reset() to start an episode, step() to take an action and get an observation and reward, and state() to inspect the episode. Calls can be sync or async.
The catalog lists more than 40 environments, including games, coding sandboxes, browsers, finance tasks, and simulators. Training integrations named in the docs include TRL, Unsloth, SkyRL, ART, Oumi, and torchforge. A Harbor environment runs coding agents such as Claude Code, Codex, and OpenCode and captures their tokens for reinforcement learning.
Example: to train a coding agent, an environment provides the repository, exposes the allowed actions, applies the agent's changes, runs the tests, and returns the result as an observation and reward. Every agent you compare faces the same repository and the same tests.
Watch out: a shared interface does not make a benchmark meaningful. Scores depend on task choice, scoring method, data quality, and how close the environment is to real use. Document your conditions, and do not compare scores across different environments as if they were the same test.
import asyncio
from echo_env import CallToolAction, EchoEnv
async def main():
async with EchoEnv(base_url="https://openenv-echo-env.hf.space") as client:
result = await client.reset()
print(result.observation.metadata["message"])
result = await client.step(
CallToolAction(
tool_name="echo_message",
arguments={"message": "Hello, World!"},
)
)
print(result.observation.result["data"])
print(result.reward)
asyncio.run(main())pip install openenv
pip install git+https://huggingface.co/spaces/openenv/echo_envTip
The docs include a five-part getting started series that needs no GPU. Run it before you plan a training pipeline around OpenEnv.
OpenSandbox: an isolated place to run agent-generated code
A sandbox platform for AI applications with SDKs in several languages, one sandbox API, and Docker or Kubernetes runtimes.
Problem it solves: agents need to run code, inspect repositories, drive browsers, and execute multi-step workflows. Doing that on a developer laptop or an application server gives generated code the same access as everything else on that machine.
OpenSandbox runs that work in an isolated environment behind a single API. SDKs exist for Python, Java and Kotlin, TypeScript and JavaScript, C# and .NET, and Go, plus a CLI (osb) and an MCP server. Docker handles local execution, Kubernetes handles cluster deployment, and a faster runtime uses Firecracker microVMs on Kubernetes. It is Apache 2.0 licensed.
Example: an agent needs to analyze a CSV with Python. Instead of running generated code on your server, the app creates a sandbox, gives it only that file, runs the code, and returns only the permitted output.
Watch out: containers alone do not make a sandbox secure. Isolation depends on configuration, runtime hardening, network policy, credential handling, host protections, and the permissions you grant the workload. Keep secrets out of the sandbox, set resource limits and network rules, and test that the boundary holds before you route real data through it.
uvx opensandbox-server init-config ~/.sandbox.toml --example docker
uvx opensandbox-serveruvx opensandbox-server init-config "$HOME\.sandbox.toml" --example docker
uvx opensandbox-serverpip install opensandbox # Python SDK
npm install @alibaba-group/opensandbox # TypeScript SDK
pip install opensandbox-cli # osb commandTip
The README lists Docker and Python 3.10+ as requirements without naming operating systems. On Windows, Docker Desktop with WSL 2 is the path we would try first. That is our suggestion, not a documented requirement.
How do the four projects fit together?
They sit at different layers. Use one, several, or none, depending on the problem you have now.
Picture a coding assistant built from all four. Agent Skills holds the team's code-review and testing procedures. Open Responses is how the app talks to whichever model provider it uses. OpenEnv provides repeatable repository tasks for evaluating or training the agent. OpenSandbox runs the code the agent writes, away from your servers.
In that design, a task arrives, the agent loads the matching skill, calls the model through one interface, tests its work in an isolated environment, and returns the result.
This is an illustration, not a claim that the four integrate out of the box. Each has its own release cycle, and any integration between specific versions is work you have to do and verify.
What to check before you adopt any of them
Run a small, representative workload against your current setup before you commit, and test the security boundary first.
Compatibility: does it support your language, framework, and deployment target? Is the feature you need implemented in the version you would ship? Does it fit your model and tool stack?
Security: how are permissions enforced and secrets handled? Can untrusted content influence what runs? What isolation and network controls exist? How are vulnerabilities reported and fixed?
Governance and licence: which licence covers the spec, the code, and supporting assets? Who maintains it, how are changes approved, and is there a versioning and compatibility policy?
Operational readiness: are install and deploy docs complete? Are there tests, examples, and troubleshooting guides? Can you monitor failures and recover an interrupted workflow?
Evaluation: pick a small workload, measure your current implementation as a baseline, then measure compatibility, correctness, latency, reliability, and cost with the new project. Adopt one piece at a time and write down the gaps you find.
The four projects at a glance
| Project and contributor | What it is for |
|---|---|
| Agent Skills (Anthropic) | Package reusable instructions, scripts, and reference files that agents load on demand. |
| Open Responses (OpenAI) | One open request and response format for calling many model providers. |
| OpenEnv (Hugging Face) | Interoperable environments for agent training, reinforcement learning, and evaluation. |
| OpenSandbox (Alibaba) | Isolated runtimes for executing agent-generated code and workflows. |
Which one should you look at first?
- Agent Skills: your agents keep getting the same procedure wrong, or you paste the same long instructions into every project.
- Open Responses: you support more than one model provider, or expect to, and the adapter code is growing.
- OpenEnv: you are building training pipelines, reinforcement learning workflows, or repeatable evaluation tasks.
- OpenSandbox: your app runs generated code, and today that code runs with the same access as your application.
- None of them: if none of those problems is real for you yet, wait. You do not need all four to benefit from open agent infrastructure.
What to watch next
The announcement establishes that the projects were contributed. It does not show that all four are equally mature or that their roadmaps are settled.
- Specification releases and breaking changes.
- Maintainer lists and governance documents.
- Security advisories and how quickly they are handled.
- Independent implementations and interoperability test results.
- Production use backed by technical write-ups, not press quotes.
The trade-offs worth knowing
- Early projects move. OpenEnv says its APIs may still change, so pin versions and expect migration work.
- A common format adds a layer. Open Responses can hide useful provider features behind a lowest common denominator unless you use the prefixed extensions.
- Skills spread instructions and scripts across teams. That is the point, and it also means a bad or malicious skill spreads the same way.
- A sandbox platform is infrastructure you now run and patch. A misconfigured sandbox can give false confidence.
- Benchmarks built on shared environments are easy to publish and easy to over-read.
Our verdict
Agent Skills is the easiest to adopt today: it is a folder of Markdown, the spec is short, and many agents already load it. Open Responses is worth adopting if you already juggle providers. OpenEnv and OpenSandbox solve real problems but ask for more infrastructure and more testing before production use.
Foundation hosting is a good sign for long-term neutrality. Judge each project on its code, docs, and security record, not on the logo above it.
My verdict: start with Agent Skills for any workflow you repeat, move to Open Responses when a second model provider shows up, and bring in OpenSandbox before you let an agent run generated code anywhere near real data. Try OpenEnv when you are ready to measure agents, not before.
Frequently asked questions
What is the Agentic AI Foundation?+
A Linux Foundation project that provides a vendor-neutral home for open AI agent standards and tools. It hosts MCP, A2A, AGENTS.md, goose, Agent Router, agentgateway, and since October 22, 2026, Agent Skills, Open Responses, OpenEnv, and OpenSandbox.
Do I need all four projects?+
No. They solve different problems at different layers. Adopt the one that matches a problem you have now, and ignore the rest until you need them.
Does Open Responses make all model providers behave the same?+
No. It standardizes the request and response format. Providers still differ in tool support, context limits, multimodal input, error behavior, latency, and price, so test each feature you depend on.
Are Agent Skills safe to download and use?+
Not automatically. A skill can steer the agent and include scripts it may run. Review third-party skills like any other code, and limit what your agent is allowed to execute.
Is OpenEnv only for reinforcement learning?+
No. It was built for RL, but the same reset, step, and state environments are useful for repeatable evaluation of any agent, and MCP environments can serve tools to agents.
Does OpenSandbox work on Windows?+
The README requires Docker and Python 3.10+ and does not list operating systems. Docker Desktop with WSL 2 is the likely path on Windows, but test it before relying on it.
Does moving to a foundation mean these projects are production-ready?+
No. Foundation hosting covers governance and neutrality. Maturity, compatibility, and security still have to be checked project by project and version by version.